From 456a2a2ab692e57be2926280ed57c7779f00b6bb Mon Sep 17 00:00:00 2001 From: Radu Berinde Date: Wed, 19 Jul 2023 10:20:39 -0700 Subject: [PATCH] objstorage: rename Shared to Remote in the objstorage provider API `IsShared()` is split into `IsRemote()`, `IsShared()`, `IsExternal()`. --- cleaner.go | 4 +- db.go | 24 +++--- ingest.go | 8 +- ingest_test.go | 2 +- objstorage/objstorage.go | 77 ++++++++++------- objstorage/objstorageprovider/provider.go | 24 +++--- .../objstorageprovider/provider_test.go | 30 +++---- objstorage/objstorageprovider/shared.go | 50 +++++------ .../objstorageprovider/shared_backing.go | 86 +++++++++---------- .../objstorageprovider/shared_backing_test.go | 30 +++---- .../objstorageprovider/shared_obj_name.go | 24 +++--- .../shared_obj_name_test.go | 14 +-- objstorage/shared/storage.go | 2 +- open.go | 2 +- scan_internal.go | 4 +- 15 files changed, 198 insertions(+), 183 deletions(-) diff --git a/cleaner.go b/cleaner.go index 85f2c67606..f9fa43b32c 100644 --- a/cleaner.go +++ b/cleaner.go @@ -181,8 +181,8 @@ func (cm *cleanupManager) needsPacing(fileType base.FileType, fileNum base.DiskF // delete anything, so we don't need to pace. return false } - // Don't throttle deletion of shared objects. - return !meta.IsShared() + // Don't throttle deletion of remote objects. + return !meta.IsRemote() } // maybePace sleeps before deleting an object if appropriate. It is always diff --git a/db.go b/db.go index 4b4a6aa3c4..40c957eac7 100644 --- a/db.go +++ b/db.go @@ -2005,15 +2005,17 @@ func (d *DB) SSTables(opts ...SSTablesOption) ([][]SSTableInfo, error) { if err != nil { return nil, err } - if objMeta.IsShared() { - if d.objProvider.IsForeign(objMeta) { - destTables[j].BackingType = BackingTypeSharedForeign - } else if objMeta.Shared.CleanupMethod == objstorage.SharedNoCleanup { - destTables[j].BackingType = BackingTypeExternal + if objMeta.IsRemote() { + if objMeta.IsShared() { + if d.objProvider.IsForeign(objMeta) { + destTables[j].BackingType = BackingTypeSharedForeign + } else { + destTables[j].BackingType = BackingTypeShared + } } else { - destTables[j].BackingType = BackingTypeShared + destTables[j].BackingType = BackingTypeExternal } - destTables[j].Locator = objMeta.Shared.Locator + destTables[j].Locator = objMeta.Remote.Locator } else { destTables[j].BackingType = BackingTypeLocal } @@ -2102,9 +2104,9 @@ func (d *DB) EstimateDiskUsageByBackingType( if err != nil { return 0, 0, 0, err } - if meta.IsShared() { + if meta.IsRemote() { remoteSize += file.Size - if meta.Shared.CleanupMethod == objstorage.SharedNoCleanup { + if meta.Remote.CleanupMethod == objstorage.SharedNoCleanup { externalSize += file.Size } } @@ -2137,9 +2139,9 @@ func (d *DB) EstimateDiskUsageByBackingType( if err != nil { return 0, 0, 0, err } - if meta.IsShared() { + if meta.IsRemote() { remoteSize += size - if meta.Shared.CleanupMethod == objstorage.SharedNoCleanup { + if meta.Remote.CleanupMethod == objstorage.SharedNoCleanup { externalSize += size } } diff --git a/ingest.go b/ingest.go index 07e55eb3d7..c9e8570935 100644 --- a/ingest.go +++ b/ingest.go @@ -449,19 +449,19 @@ func ingestLink( }) } } - sharedObjs := make([]objstorage.SharedObjectToAttach, 0, len(shared)) + sharedObjs := make([]objstorage.RemoteObjectToAttach, 0, len(shared)) for i := range shared { backing, err := shared[i].Backing.Get() if err != nil { return err } - sharedObjs = append(sharedObjs, objstorage.SharedObjectToAttach{ + sharedObjs = append(sharedObjs, objstorage.RemoteObjectToAttach{ FileNum: lr.sharedMeta[i].FileBacking.DiskFileNum, FileType: fileTypeTable, Backing: backing, }) } - sharedObjMetas, err := objProvider.AttachSharedObjects(sharedObjs) + sharedObjMetas, err := objProvider.AttachRemoteObjects(sharedObjs) if err != nil { return err } @@ -473,7 +473,7 @@ func ingestLink( // open the db again after a crash/restart (see checkConsistency in open.go), // plus it more accurately allows us to prioritize compactions of files // that were originally created by us. - if !objProvider.IsForeign(sharedObjMetas[i]) { + if sharedObjMetas[i].IsShared() && !objProvider.IsForeign(sharedObjMetas[i]) { size, err := objProvider.Size(sharedObjMetas[i]) if err != nil { return err diff --git a/ingest_test.go b/ingest_test.go index 8374ab5cbb..b8666af02b 100644 --- a/ingest_test.go +++ b/ingest_test.go @@ -1092,7 +1092,7 @@ func TestSimpleIngestShared(t *testing.T) { } m := metaMap[base.FileNum(2).DiskFileNum()] - handle, err := provider2.SharedObjectBacking(&m) + handle, err := provider2.RemoteObjectBacking(&m) require.NoError(t, err) size, err := provider2.Size(m) require.NoError(t, err) diff --git a/objstorage/objstorage.go b/objstorage/objstorage.go index dc34f369cf..f5f5751eda 100644 --- a/objstorage/objstorage.go +++ b/objstorage/objstorage.go @@ -89,8 +89,8 @@ type ObjectMetadata struct { DiskFileNum base.DiskFileNum FileType base.FileType - // The fields below are only set if the object is on shared storage. - Shared struct { + // The fields below are only set if the object is on remote storage. + Remote struct { // CreatorID identifies the DB instance that originally created the object. // // Only used when CustomObjectName is not set. @@ -113,31 +113,44 @@ type ObjectMetadata struct { } } -// IsShared returns true if the object is on shared storage. +// IsRemote returns true if the object is on remote storage. +func (meta *ObjectMetadata) IsRemote() bool { + return meta.IsShared() || meta.IsExternal() +} + +// IsExternal returns true if the object is on remote storage but is not owned +// by any Pebble instances in the cluster. +func (meta *ObjectMetadata) IsExternal() bool { + return meta.Remote.CustomObjectName != "" +} + +// IsShared returns true if the object is on remote storage and is owned by a +// Pebble instance in the cluster (potentially shared between multiple +// instances). func (meta *ObjectMetadata) IsShared() bool { - return meta.Shared.CreatorID.IsSet() || meta.Shared.CustomObjectName != "" + return meta.Remote.CreatorID.IsSet() } // AssertValid checks that the metadata is sane. func (meta *ObjectMetadata) AssertValid() { - if !meta.IsShared() { - // Verify all Shared fields are empty. - if meta.Shared != (ObjectMetadata{}).Shared { - panic(errors.AssertionFailedf("meta.Shared not empty: %#v", meta.Shared)) + if !meta.IsRemote() { + // Verify all Remote fields are empty. + if meta.Remote != (ObjectMetadata{}).Remote { + panic(errors.AssertionFailedf("meta.Remote not empty: %#v", meta.Remote)) } } else { - if meta.Shared.CustomObjectName != "" { - if meta.Shared.CreatorID == 0 { + if meta.Remote.CustomObjectName != "" { + if meta.Remote.CreatorID == 0 { panic(errors.AssertionFailedf("CreatorID not set")) } - if meta.Shared.CreatorFileNum == base.FileNum(0).DiskFileNum() { + if meta.Remote.CreatorFileNum == base.FileNum(0).DiskFileNum() { panic(errors.AssertionFailedf("CreatorFileNum not set")) } } - if meta.Shared.CleanupMethod != SharedNoCleanup && meta.Shared.CleanupMethod != SharedRefTracking { - panic(errors.AssertionFailedf("invalid CleanupMethod %d", meta.Shared.CleanupMethod)) + if meta.Remote.CleanupMethod != SharedNoCleanup && meta.Remote.CleanupMethod != SharedRefTracking { + panic(errors.AssertionFailedf("invalid CleanupMethod %d", meta.Remote.CleanupMethod)) } - if meta.Shared.Storage == nil { + if meta.Remote.Storage == nil { panic(errors.AssertionFailedf("Storage not set")) } } @@ -161,7 +174,7 @@ const ( // keep track of references via reference marker objects. SharedRefTracking SharedCleanupMethod = iota - // SharedNoCleanup is used for shared objects that are managed externally; the + // SharedNoCleanup is used for remote objects that are managed externally; the // objstorage provider never deletes such objects. SharedNoCleanup ) @@ -249,7 +262,7 @@ type Provider interface { List() []ObjectMetadata // SetCreatorID sets the CreatorID which is needed in order to use shared - // objects. Shared object usage is disabled until this method is called the + // objects. Remote object usage is disabled until this method is called the // first time. Once set, the Creator ID is persisted and cannot change. // // Cannot be called if shared storage is not configured for the provider. @@ -260,16 +273,16 @@ type Provider interface { // exist in this provider. IsForeign(meta ObjectMetadata) bool - // SharedObjectBacking encodes the shared object metadata for the given object. - SharedObjectBacking(meta *ObjectMetadata) (SharedObjectBackingHandle, error) + // RemoteObjectBacking encodes the remote object metadata for the given object. + RemoteObjectBacking(meta *ObjectMetadata) (RemoteObjectBackingHandle, error) - // CreateSharedObjectBacking creates a backing for an existing object with a + // CreateExternalObjectBacking creates a backing for an existing object with a // custom object name. The object is considered to be managed outside of // Pebble and will never be removed by Pebble. - CreateSharedObjectBacking(locator shared.Locator, objName string) (SharedObjectBacking, error) + CreateExternalObjectBacking(locator shared.Locator, objName string) (RemoteObjectBacking, error) - // AttachSharedObjects registers existing shared objects with this provider. - AttachSharedObjects(objs []SharedObjectToAttach) ([]ObjectMetadata, error) + // AttachRemoteObjects registers existing remote objects with this provider. + AttachRemoteObjects(objs []RemoteObjectToAttach) ([]ObjectMetadata, error) Close() error @@ -278,31 +291,31 @@ type Provider interface { IsNotExistError(err error) bool } -// SharedObjectBacking encodes the metadata necessary to incorporate a shared +// RemoteObjectBacking encodes the metadata necessary to incorporate a shared // object into a different Pebble instance. The encoding is specific to a given // Provider implementation. -type SharedObjectBacking []byte +type RemoteObjectBacking []byte -// SharedObjectBackingHandle is a container for a SharedObjectBacking which +// RemoteObjectBackingHandle is a container for a RemoteObjectBacking which // ensures that the backing stays valid. A backing can otherwise become invalid -// if this provider unrefs the shared object. The SharedObjectBackingHandle +// if this provider unrefs the shared object. The RemoteObjectBackingHandle // delays any unref until Close. -type SharedObjectBackingHandle interface { +type RemoteObjectBackingHandle interface { // Get returns the backing. The backing is only guaranteed to be valid until // Close is called (or until the Provider is closed). If Close was already // called, returns an error. - Get() (SharedObjectBacking, error) + Get() (RemoteObjectBacking, error) Close() } -// SharedObjectToAttach contains the arguments needed to attach an existing shared object. -type SharedObjectToAttach struct { +// RemoteObjectToAttach contains the arguments needed to attach an existing remote object. +type RemoteObjectToAttach struct { // FileNum is the file number that will be used to refer to this object (in // the context of this instance). FileNum base.DiskFileNum FileType base.FileType - // Backing contains the metadata for the shared object backing (normally + // Backing contains the metadata for the remote object backing (normally // generated from a different instance, but using the same Provider // implementation). - Backing SharedObjectBacking + Backing RemoteObjectBacking } diff --git a/objstorage/objstorageprovider/provider.go b/objstorage/objstorageprovider/provider.go index 6de07d69b7..f009003c6c 100644 --- a/objstorage/objstorageprovider/provider.go +++ b/objstorage/objstorageprovider/provider.go @@ -214,7 +214,7 @@ func (p *provider) OpenForReading( } var r objstorage.Readable - if !meta.IsShared() { + if !meta.IsRemote() { r, err = p.vfsOpenForReading(ctx, fileType, fileNum, opts) } else { r, err = p.sharedOpenForReading(ctx, meta, opts) @@ -271,7 +271,7 @@ func (p *provider) Remove(fileType base.FileType, fileNum base.DiskFileNum) erro return err } - if !meta.IsShared() { + if !meta.IsRemote() { err = p.vfsRemove(fileType, fileNum) } else { // TODO(radu): implement shared object removal (i.e. deref). @@ -293,8 +293,8 @@ func (p *provider) Remove(fileType base.FileType, fileNum base.DiskFileNum) erro } func (p *provider) isNotExistError(meta objstorage.ObjectMetadata, err error) bool { - if meta.Shared.Storage != nil { - return meta.Shared.Storage.IsNotExistError(err) + if meta.Remote.Storage != nil { + return meta.Remote.Storage.IsNotExistError(err) } return oserror.IsNotExist(err) } @@ -411,7 +411,7 @@ func (p *provider) Lookup( // Path is part of the objstorage.Provider interface. func (p *provider) Path(meta objstorage.ObjectMetadata) string { - if !meta.IsShared() { + if !meta.IsRemote() { return p.vfsPath(meta.FileType, meta.DiskFileNum) } return p.sharedPath(meta) @@ -419,7 +419,7 @@ func (p *provider) Path(meta objstorage.ObjectMetadata) string { // Size returns the size of the object. func (p *provider) Size(meta objstorage.ObjectMetadata) (int64, error) { - if !meta.IsShared() { + if !meta.IsRemote() { return p.vfsSize(meta.FileType, meta.DiskFileNum) } return p.sharedSize(meta) @@ -446,14 +446,14 @@ func (p *provider) addMetadata(meta objstorage.ObjectMetadata) { p.mu.Lock() defer p.mu.Unlock() p.mu.knownObjects[meta.DiskFileNum] = meta - if meta.IsShared() { + if meta.IsRemote() { p.mu.shared.catalogBatch.AddObject(sharedobjcat.SharedObjectMetadata{ FileNum: meta.DiskFileNum, FileType: meta.FileType, - CreatorID: meta.Shared.CreatorID, - CreatorFileNum: meta.Shared.CreatorFileNum, - Locator: meta.Shared.Locator, - CleanupMethod: meta.Shared.CleanupMethod, + CreatorID: meta.Remote.CreatorID, + CreatorFileNum: meta.Remote.CreatorFileNum, + Locator: meta.Remote.Locator, + CleanupMethod: meta.Remote.CleanupMethod, }) } else { p.mu.localObjectsChanged = true @@ -469,7 +469,7 @@ func (p *provider) removeMetadata(fileNum base.DiskFileNum) { return } delete(p.mu.knownObjects, fileNum) - if meta.IsShared() { + if meta.IsRemote() { p.mu.shared.catalogBatch.DeleteObject(fileNum) } else { p.mu.localObjectsChanged = true diff --git a/objstorage/objstorageprovider/provider_test.go b/objstorage/objstorageprovider/provider_test.go index 120794c051..f3bf03c31c 100644 --- a/objstorage/objstorageprovider/provider_test.go +++ b/objstorage/objstorageprovider/provider_test.go @@ -35,8 +35,8 @@ func TestProvider(t *testing.T) { providers := make(map[string]objstorage.Provider) // We maintain both backings and backing handles to allow tests to use the // backings after the handles have been closed. - backings := make(map[string]objstorage.SharedObjectBacking) - backingHandles := make(map[string]objstorage.SharedObjectBackingHandle) + backings := make(map[string]objstorage.RemoteObjectBacking) + backingHandles := make(map[string]objstorage.RemoteObjectBackingHandle) var curProvider objstorage.Provider datadriven.RunTest(t, path, func(t *testing.T, d *datadriven.TestData) string { scanArgs := func(desc string, args ...interface{}) { @@ -220,7 +220,7 @@ func TestProvider(t *testing.T) { scanArgs(" ", &key, &fileNum) meta, err := curProvider.Lookup(base.FileTypeTable, fileNum.DiskFileNum()) require.NoError(t, err) - handle, err := curProvider.SharedObjectBacking(&meta) + handle, err := curProvider.RemoteObjectBacking(&meta) if err != nil { return err.Error() } @@ -241,7 +241,7 @@ func TestProvider(t *testing.T) { if len(lines) == 0 { d.Fatalf(t, "at least one row expected; format: ") } - var objs []objstorage.SharedObjectToAttach + var objs []objstorage.RemoteObjectToAttach for _, l := range lines { var key string var fileNum base.FileNum @@ -251,13 +251,13 @@ func TestProvider(t *testing.T) { if !ok { d.Fatalf(t, "unknown backing key %q", key) } - objs = append(objs, objstorage.SharedObjectToAttach{ + objs = append(objs, objstorage.RemoteObjectToAttach{ FileType: base.FileTypeTable, FileNum: fileNum.DiskFileNum(), Backing: b, }) } - metas, err := curProvider.AttachSharedObjects(objs) + metas, err := curProvider.AttachRemoteObjects(objs) if err != nil { return log.String() + "error: " + err.Error() } @@ -326,12 +326,12 @@ func TestSharedMultipleLocators(t *testing.T) { // Now attach p1's object (in the "foo" store) to p2. meta1, err := p1.Lookup(base.FileTypeTable, file1) require.NoError(t, err) - h1, err := p1.SharedObjectBacking(&meta1) + h1, err := p1.RemoteObjectBacking(&meta1) require.NoError(t, err) b1, err := h1.Get() require.NoError(t, err) - _, err = p2.AttachSharedObjects([]objstorage.SharedObjectToAttach{{ + _, err = p2.AttachRemoteObjects([]objstorage.RemoteObjectToAttach{{ FileNum: file2, FileType: base.FileTypeTable, Backing: b1, @@ -344,11 +344,11 @@ func TestSharedMultipleLocators(t *testing.T) { // Now attach p2's object (in the "bar" store) to p1. meta2, err := p2.Lookup(base.FileTypeTable, file1) require.NoError(t, err) - h2, err := p2.SharedObjectBacking(&meta2) + h2, err := p2.RemoteObjectBacking(&meta2) require.NoError(t, err) b2, err := h2.Get() require.NoError(t, err) - _, err = p1.AttachSharedObjects([]objstorage.SharedObjectToAttach{{ + _, err = p1.AttachRemoteObjects([]objstorage.RemoteObjectToAttach{{ FileNum: file2, FileType: base.FileTypeTable, Backing: b2, @@ -373,7 +373,7 @@ func TestSharedMultipleLocators(t *testing.T) { p3, err := Open(st3) require.NoError(t, err) require.NoError(t, p3.SetCreatorID(3)) - _, err = p3.AttachSharedObjects([]objstorage.SharedObjectToAttach{{ + _, err = p3.AttachRemoteObjects([]objstorage.RemoteObjectToAttach{{ FileNum: file2, FileType: base.FileTypeTable, Backing: b2, @@ -404,10 +404,10 @@ func TestAttachCustomObject(t *testing.T) { require.NoError(t, err) require.NoError(t, w.Close()) - backing, err := p1.CreateSharedObjectBacking("foo", "some-obj-name") + backing, err := p1.CreateExternalObjectBacking("foo", "some-obj-name") require.NoError(t, err) - _, err = p1.AttachSharedObjects([]objstorage.SharedObjectToAttach{{ + _, err = p1.AttachRemoteObjects([]objstorage.RemoteObjectToAttach{{ FileNum: base.FileNum(1).DiskFileNum(), FileType: base.FileTypeTable, Backing: backing, @@ -427,7 +427,7 @@ func TestAttachCustomObject(t *testing.T) { // the object to another provider. meta, err := p1.Lookup(base.FileTypeTable, base.FileNum(1).DiskFileNum()) require.NoError(t, err) - handle, err := p1.SharedObjectBacking(&meta) + handle, err := p1.RemoteObjectBacking(&meta) require.NoError(t, err) defer handle.Close() backing, err = handle.Get() @@ -440,7 +440,7 @@ func TestAttachCustomObject(t *testing.T) { defer p2.Close() require.NoError(t, p2.SetCreatorID(2)) - _, err = p2.AttachSharedObjects([]objstorage.SharedObjectToAttach{{ + _, err = p2.AttachRemoteObjects([]objstorage.RemoteObjectToAttach{{ FileNum: base.FileNum(10).DiskFileNum(), FileType: base.FileTypeTable, Backing: backing, diff --git a/objstorage/objstorageprovider/shared.go b/objstorage/objstorageprovider/shared.go index 74b929b341..7f25e9f00d 100644 --- a/objstorage/objstorageprovider/shared.go +++ b/objstorage/objstorageprovider/shared.go @@ -94,14 +94,14 @@ func (p *provider) sharedInit() error { DiskFileNum: meta.FileNum, FileType: meta.FileType, } - o.Shared.CreatorID = meta.CreatorID - o.Shared.CreatorFileNum = meta.CreatorFileNum - o.Shared.CleanupMethod = meta.CleanupMethod - o.Shared.Locator = meta.Locator - o.Shared.CustomObjectName = meta.CustomObjectName - o.Shared.Storage, err = p.ensureStorageLocked(o.Shared.Locator) + o.Remote.CreatorID = meta.CreatorID + o.Remote.CreatorFileNum = meta.CreatorFileNum + o.Remote.CleanupMethod = meta.CleanupMethod + o.Remote.Locator = meta.Locator + o.Remote.CustomObjectName = meta.CustomObjectName + o.Remote.Storage, err = p.ensureStorageLocked(o.Remote.Locator) if err != nil { - return errors.Wrapf(err, "creating shared.Storage object for locator '%s'", o.Shared.Locator) + return errors.Wrapf(err, "creating shared.Storage object for locator '%s'", o.Remote.Locator) } if invariants.Enabled { o.AssertValid() @@ -149,7 +149,7 @@ func (p *provider) IsForeign(meta objstorage.ObjectMetadata) bool { if !p.shared.initialized.Load() { return false } - return meta.IsShared() && (meta.Shared.CustomObjectName != "" || meta.Shared.CreatorID != p.shared.creatorID) + return meta.IsRemote() && (meta.Remote.CustomObjectName != "" || meta.Remote.CreatorID != p.shared.creatorID) } func (p *provider) sharedCheckInitialized() error { @@ -194,11 +194,11 @@ func (p *provider) sharedPath(meta objstorage.ObjectMetadata) string { // sharedCreateRef creates a reference marker object. func (p *provider) sharedCreateRef(meta objstorage.ObjectMetadata) error { - if meta.Shared.CleanupMethod != objstorage.SharedRefTracking { + if meta.Remote.CleanupMethod != objstorage.SharedRefTracking { return nil } refName := p.sharedObjectRefName(meta) - writer, err := meta.Shared.Storage.CreateObject(refName) + writer, err := meta.Remote.Storage.CreateObject(refName) if err == nil { // The object is empty, just close the writer. err = writer.Close() @@ -227,11 +227,11 @@ func (p *provider) sharedCreate( DiskFileNum: fileNum, FileType: fileType, } - meta.Shared.CreatorID = p.shared.creatorID - meta.Shared.CreatorFileNum = fileNum - meta.Shared.CleanupMethod = opts.SharedCleanupMethod - meta.Shared.Locator = locator - meta.Shared.Storage = storage + meta.Remote.CreatorID = p.shared.creatorID + meta.Remote.CreatorFileNum = fileNum + meta.Remote.CleanupMethod = opts.SharedCleanupMethod + meta.Remote.Locator = locator + meta.Remote.Storage = storage objName := sharedObjectName(meta) writer, err := storage.CreateObject(objName) @@ -253,10 +253,10 @@ func (p *provider) sharedOpenForReading( } // Verify we have a reference on this object; for performance reasons, we only // do this in testing scenarios. - if p.shared.checkRefsOnOpen && meta.Shared.CleanupMethod == objstorage.SharedRefTracking { + if p.shared.checkRefsOnOpen && meta.Remote.CleanupMethod == objstorage.SharedRefTracking { refName := p.sharedObjectRefName(meta) - if _, err := meta.Shared.Storage.Size(refName); err != nil { - if meta.Shared.Storage.IsNotExistError(err) { + if _, err := meta.Remote.Storage.Size(refName); err != nil { + if meta.Remote.Storage.IsNotExistError(err) { if opts.MustExist { p.st.Logger.Fatalf("marker object %q does not exist", refName) // TODO(radu): maybe list references for the object. @@ -267,9 +267,9 @@ func (p *provider) sharedOpenForReading( } } objName := sharedObjectName(meta) - reader, size, err := meta.Shared.Storage.ReadObject(ctx, objName) + reader, size, err := meta.Remote.Storage.ReadObject(ctx, objName) if err != nil { - if opts.MustExist && meta.Shared.Storage.IsNotExistError(err) { + if opts.MustExist && meta.Remote.Storage.IsNotExistError(err) { p.st.Logger.Fatalf("object %q does not exist", objName) // TODO(radu): maybe list references for the object. } @@ -283,14 +283,14 @@ func (p *provider) sharedSize(meta objstorage.ObjectMetadata) (int64, error) { return 0, err } objName := sharedObjectName(meta) - return meta.Shared.Storage.Size(objName) + return meta.Remote.Storage.Size(objName) } // sharedUnref implements object "removal" with the shared backend. The ref // marker object is removed and the backing object is removed only if there are // no other ref markers. func (p *provider) sharedUnref(meta objstorage.ObjectMetadata) error { - if meta.Shared.CleanupMethod == objstorage.SharedNoCleanup { + if meta.Remote.CleanupMethod == objstorage.SharedNoCleanup { // Never delete objects in this mode. return nil } @@ -302,16 +302,16 @@ func (p *provider) sharedUnref(meta objstorage.ObjectMetadata) error { refName := p.sharedObjectRefName(meta) // Tolerate a not-exists error. - if err := meta.Shared.Storage.Delete(refName); err != nil && !meta.Shared.Storage.IsNotExistError(err) { + if err := meta.Remote.Storage.Delete(refName); err != nil && !meta.Remote.Storage.IsNotExistError(err) { return err } - otherRefs, err := meta.Shared.Storage.List(sharedObjectRefPrefix(meta), "" /* delimiter */) + otherRefs, err := meta.Remote.Storage.List(sharedObjectRefPrefix(meta), "" /* delimiter */) if err != nil { return err } if len(otherRefs) == 0 { objName := sharedObjectName(meta) - if err := meta.Shared.Storage.Delete(objName); err != nil && !meta.Shared.Storage.IsNotExistError(err) { + if err := meta.Remote.Storage.Delete(objName); err != nil && !meta.Remote.Storage.IsNotExistError(err) { return err } } diff --git a/objstorage/objstorageprovider/shared_backing.go b/objstorage/objstorageprovider/shared_backing.go index fcd3908dd2..fe5d86815f 100644 --- a/objstorage/objstorageprovider/shared_backing.go +++ b/objstorage/objstorageprovider/shared_backing.go @@ -43,44 +43,44 @@ const ( func (p *provider) encodeSharedObjectBacking( meta *objstorage.ObjectMetadata, -) (objstorage.SharedObjectBacking, error) { - if !meta.IsShared() { +) (objstorage.RemoteObjectBacking, error) { + if !meta.IsRemote() { return nil, errors.AssertionFailedf("object %s not on shared storage", meta.DiskFileNum) } buf := make([]byte, 0, binary.MaxVarintLen64*4) buf = binary.AppendUvarint(buf, tagCreatorID) - buf = binary.AppendUvarint(buf, uint64(meta.Shared.CreatorID)) + buf = binary.AppendUvarint(buf, uint64(meta.Remote.CreatorID)) // TODO(radu): encode file type as well? buf = binary.AppendUvarint(buf, tagCreatorFileNum) - buf = binary.AppendUvarint(buf, uint64(meta.Shared.CreatorFileNum.FileNum())) + buf = binary.AppendUvarint(buf, uint64(meta.Remote.CreatorFileNum.FileNum())) buf = binary.AppendUvarint(buf, tagCleanupMethod) - buf = binary.AppendUvarint(buf, uint64(meta.Shared.CleanupMethod)) - if meta.Shared.CleanupMethod == objstorage.SharedRefTracking { + buf = binary.AppendUvarint(buf, uint64(meta.Remote.CleanupMethod)) + if meta.Remote.CleanupMethod == objstorage.SharedRefTracking { buf = binary.AppendUvarint(buf, tagRefCheckID) buf = binary.AppendUvarint(buf, uint64(p.shared.creatorID)) buf = binary.AppendUvarint(buf, uint64(meta.DiskFileNum.FileNum())) } - if meta.Shared.Locator != "" { + if meta.Remote.Locator != "" { buf = binary.AppendUvarint(buf, tagLocator) - buf = encodeString(buf, string(meta.Shared.Locator)) + buf = encodeString(buf, string(meta.Remote.Locator)) } - if meta.Shared.CustomObjectName != "" { + if meta.Remote.CustomObjectName != "" { buf = binary.AppendUvarint(buf, tagCustomObjectName) - buf = encodeString(buf, meta.Shared.CustomObjectName) + buf = encodeString(buf, meta.Remote.CustomObjectName) } return buf, nil } type sharedObjectBackingHandle struct { - backing objstorage.SharedObjectBacking + backing objstorage.RemoteObjectBacking fileNum base.DiskFileNum p *provider } -func (s *sharedObjectBackingHandle) Get() (objstorage.SharedObjectBacking, error) { +func (s *sharedObjectBackingHandle) Get() (objstorage.RemoteObjectBacking, error) { if s.backing == nil { - return nil, errors.Errorf("SharedObjectBackingHandle.Get() called after Close()") + return nil, errors.Errorf("RemoteObjectBackingHandle.Get() called after Close()") } return s.backing, nil } @@ -92,12 +92,12 @@ func (s *sharedObjectBackingHandle) Close() { } } -var _ objstorage.SharedObjectBackingHandle = (*sharedObjectBackingHandle)(nil) +var _ objstorage.RemoteObjectBackingHandle = (*sharedObjectBackingHandle)(nil) -// SharedObjectBacking is part of the objstorage.Provider interface. -func (p *provider) SharedObjectBacking( +// RemoteObjectBacking is part of the objstorage.Provider interface. +func (p *provider) RemoteObjectBacking( meta *objstorage.ObjectMetadata, -) (objstorage.SharedObjectBackingHandle, error) { +) (objstorage.RemoteObjectBackingHandle, error) { backing, err := p.encodeSharedObjectBacking(meta) if err != nil { return nil, err @@ -110,20 +110,20 @@ func (p *provider) SharedObjectBacking( }, nil } -// CreateSharedObjectBacking is part of the objstorage.Provider interface. -func (p *provider) CreateSharedObjectBacking( +// CreateExternalObjectBacking is part of the objstorage.Provider interface. +func (p *provider) CreateExternalObjectBacking( locator shared.Locator, objName string, -) (objstorage.SharedObjectBacking, error) { +) (objstorage.RemoteObjectBacking, error) { var meta objstorage.ObjectMetadata - meta.Shared.Locator = locator - meta.Shared.CustomObjectName = objName - meta.Shared.CleanupMethod = objstorage.SharedNoCleanup + meta.Remote.Locator = locator + meta.Remote.CustomObjectName = objName + meta.Remote.CleanupMethod = objstorage.SharedNoCleanup return p.encodeSharedObjectBacking(&meta) } type decodedBacking struct { meta objstorage.ObjectMetadata - // refToCheck is set only when meta.Shared.CleanupMethod is RefTracking + // refToCheck is set only when meta.Remote.CleanupMethod is RefTracking refToCheck struct { creatorID objstorage.CreatorID fileNum base.DiskFileNum @@ -132,9 +132,9 @@ type decodedBacking struct { // decodeSharedObjectBacking decodes the shared object metadata. // -// Note that the meta.Shared.Storage field is not set. +// Note that the meta.Remote.Storage field is not set. func decodeSharedObjectBacking( - fileType base.FileType, fileNum base.DiskFileNum, buf objstorage.SharedObjectBacking, + fileType base.FileType, fileNum base.DiskFileNum, buf objstorage.RemoteObjectBacking, ) (decodedBacking, error) { var creatorID, creatorFileNum, cleanupMethod, refCheckCreatorID, refCheckFileNum uint64 var locator, customObjName string @@ -195,18 +195,18 @@ func decodeSharedObjectBacking( var res decodedBacking res.meta.DiskFileNum = fileNum res.meta.FileType = fileType - res.meta.Shared.CreatorID = objstorage.CreatorID(creatorID) - res.meta.Shared.CreatorFileNum = base.FileNum(creatorFileNum).DiskFileNum() - res.meta.Shared.CleanupMethod = objstorage.SharedCleanupMethod(cleanupMethod) - if res.meta.Shared.CleanupMethod == objstorage.SharedRefTracking { + res.meta.Remote.CreatorID = objstorage.CreatorID(creatorID) + res.meta.Remote.CreatorFileNum = base.FileNum(creatorFileNum).DiskFileNum() + res.meta.Remote.CleanupMethod = objstorage.SharedCleanupMethod(cleanupMethod) + if res.meta.Remote.CleanupMethod == objstorage.SharedRefTracking { if refCheckCreatorID == 0 || refCheckFileNum == 0 { return decodedBacking{}, errors.Newf("shared object backing missing ref to check") } res.refToCheck.creatorID = objstorage.CreatorID(refCheckCreatorID) res.refToCheck.fileNum = base.FileNum(refCheckFileNum).DiskFileNum() } - res.meta.Shared.Locator = shared.Locator(locator) - res.meta.Shared.CustomObjectName = customObjName + res.meta.Remote.Locator = shared.Locator(locator) + res.meta.Remote.CustomObjectName = customObjName return res, nil } @@ -231,9 +231,9 @@ func decodeString(br io.ByteReader) (string, error) { return string(buf), nil } -// AttachSharedObjects is part of the objstorage.Provider interface. -func (p *provider) AttachSharedObjects( - objs []objstorage.SharedObjectToAttach, +// AttachRemoteObjects is part of the objstorage.Provider interface. +func (p *provider) AttachRemoteObjects( + objs []objstorage.RemoteObjectToAttach, ) ([]objstorage.ObjectMetadata, error) { decoded := make([]decodedBacking, len(objs)) for i, o := range objs { @@ -242,7 +242,7 @@ func (p *provider) AttachSharedObjects( if err != nil { return nil, err } - decoded[i].meta.Shared.Storage, err = p.ensureStorage(decoded[i].meta.Shared.Locator) + decoded[i].meta.Remote.Storage, err = p.ensureStorage(decoded[i].meta.Remote.Locator) if err != nil { return nil, err } @@ -251,7 +251,7 @@ func (p *provider) AttachSharedObjects( // Create the reference marker objects. // TODO(radu): parallelize this. for _, d := range decoded { - if d.meta.Shared.CleanupMethod != objstorage.SharedRefTracking { + if d.meta.Remote.CleanupMethod != objstorage.SharedRefTracking { continue } if err := p.sharedCreateRef(d.meta); err != nil { @@ -260,10 +260,10 @@ func (p *provider) AttachSharedObjects( } // Check the "origin"'s reference. refName := sharedObjectRefName(d.meta, d.refToCheck.creatorID, d.refToCheck.fileNum) - if _, err := d.meta.Shared.Storage.Size(refName); err != nil { + if _, err := d.meta.Remote.Storage.Size(refName); err != nil { _ = p.sharedUnref(d.meta) // TODO(radu): clean up references previously created in this loop. - if d.meta.Shared.Storage.IsNotExistError(err) { + if d.meta.Remote.Storage.IsNotExistError(err) { return nil, errors.Errorf("origin marker object %q does not exist;"+ " object probably removed from the provider which created the backing", refName) } @@ -278,10 +278,10 @@ func (p *provider) AttachSharedObjects( p.mu.shared.catalogBatch.AddObject(sharedobjcat.SharedObjectMetadata{ FileNum: d.meta.DiskFileNum, FileType: d.meta.FileType, - CreatorID: d.meta.Shared.CreatorID, - CreatorFileNum: d.meta.Shared.CreatorFileNum, - CleanupMethod: d.meta.Shared.CleanupMethod, - Locator: d.meta.Shared.Locator, + CreatorID: d.meta.Remote.CreatorID, + CreatorFileNum: d.meta.Remote.CreatorFileNum, + CleanupMethod: d.meta.Remote.CleanupMethod, + Locator: d.meta.Remote.Locator, }) } }() diff --git a/objstorage/objstorageprovider/shared_backing_test.go b/objstorage/objstorageprovider/shared_backing_test.go index cb258f4c5c..6c5b5dfc87 100644 --- a/objstorage/objstorageprovider/shared_backing_test.go +++ b/objstorage/objstorageprovider/shared_backing_test.go @@ -37,14 +37,14 @@ func TestSharedObjectBacking(t *testing.T) { DiskFileNum: base.FileNum(1).DiskFileNum(), FileType: base.FileTypeTable, } - meta.Shared.CreatorID = 100 - meta.Shared.CreatorFileNum = base.FileNum(200).DiskFileNum() - meta.Shared.CleanupMethod = cleanup - meta.Shared.Locator = "foo" - meta.Shared.CustomObjectName = "obj-name" - meta.Shared.Storage = sharedStorage + meta.Remote.CreatorID = 100 + meta.Remote.CreatorFileNum = base.FileNum(200).DiskFileNum() + meta.Remote.CleanupMethod = cleanup + meta.Remote.Locator = "foo" + meta.Remote.CustomObjectName = "obj-name" + meta.Remote.Storage = sharedStorage - h, err := p.SharedObjectBacking(&meta) + h, err := p.RemoteObjectBacking(&meta) require.NoError(t, err) buf, err := h.Get() require.NoError(t, err) @@ -56,8 +56,8 @@ func TestSharedObjectBacking(t *testing.T) { require.NoError(t, err) require.Equal(t, uint64(100), uint64(d1.meta.DiskFileNum.FileNum())) require.Equal(t, base.FileTypeTable, d1.meta.FileType) - d1.meta.Shared.Storage = sharedStorage - require.Equal(t, meta.Shared, d1.meta.Shared) + d1.meta.Remote.Storage = sharedStorage + require.Equal(t, meta.Remote, d1.meta.Remote) if cleanup == objstorage.SharedRefTracking { require.Equal(t, creatorID, d1.refToCheck.creatorID) require.Equal(t, base.FileNum(1).DiskFileNum(), d1.refToCheck.fileNum) @@ -77,8 +77,8 @@ func TestSharedObjectBacking(t *testing.T) { require.NoError(t, err) require.Equal(t, uint64(100), uint64(d2.meta.DiskFileNum.FileNum())) require.Equal(t, base.FileTypeTable, d2.meta.FileType) - d2.meta.Shared.Storage = sharedStorage - require.Equal(t, meta.Shared, d2.meta.Shared) + d2.meta.Remote.Storage = sharedStorage + require.Equal(t, meta.Remote, d2.meta.Remote) if cleanup == objstorage.SharedRefTracking { require.Equal(t, creatorID, d2.refToCheck.creatorID) require.Equal(t, base.FileNum(1).DiskFileNum(), d2.refToCheck.fileNum) @@ -109,13 +109,13 @@ func TestCreateSharedObjectBacking(t *testing.T) { require.NoError(t, p.SetCreatorID(1)) - backing, err := p.CreateSharedObjectBacking("foo", "custom-obj-name") + backing, err := p.CreateExternalObjectBacking("foo", "custom-obj-name") require.NoError(t, err) d, err := decodeSharedObjectBacking(base.FileTypeTable, base.FileNum(100).DiskFileNum(), backing) require.NoError(t, err) require.Equal(t, uint64(100), uint64(d.meta.DiskFileNum.FileNum())) require.Equal(t, base.FileTypeTable, d.meta.FileType) - require.Equal(t, shared.Locator("foo"), d.meta.Shared.Locator) - require.Equal(t, "custom-obj-name", d.meta.Shared.CustomObjectName) - require.Equal(t, objstorage.SharedNoCleanup, d.meta.Shared.CleanupMethod) + require.Equal(t, shared.Locator("foo"), d.meta.Remote.Locator) + require.Equal(t, "custom-obj-name", d.meta.Remote.CustomObjectName) + require.Equal(t, objstorage.SharedNoCleanup, d.meta.Remote.CleanupMethod) } diff --git a/objstorage/objstorageprovider/shared_obj_name.go b/objstorage/objstorageprovider/shared_obj_name.go index ba933f1f78..f76cffff0a 100644 --- a/objstorage/objstorageprovider/shared_obj_name.go +++ b/objstorage/objstorageprovider/shared_obj_name.go @@ -16,14 +16,14 @@ import ( // For sstables, the format is: --.sst // For example: 1a3f-2-000001.sst func sharedObjectName(meta objstorage.ObjectMetadata) string { - if meta.Shared.CustomObjectName != "" { - return meta.Shared.CustomObjectName + if meta.Remote.CustomObjectName != "" { + return meta.Remote.CustomObjectName } switch meta.FileType { case base.FileTypeTable: return fmt.Sprintf( "%04x-%d-%06d.sst", - objHash(meta), meta.Shared.CreatorID, meta.Shared.CreatorFileNum.FileNum(), + objHash(meta), meta.Remote.CreatorID, meta.Remote.CreatorFileNum.FileNum(), ) } panic("unknown FileType") @@ -37,33 +37,33 @@ func sharedObjectName(meta objstorage.ObjectMetadata) string { func sharedObjectRefName( meta objstorage.ObjectMetadata, refCreatorID objstorage.CreatorID, refFileNum base.DiskFileNum, ) string { - if meta.Shared.CleanupMethod != objstorage.SharedRefTracking { + if meta.Remote.CleanupMethod != objstorage.SharedRefTracking { panic("ref object used when ref tracking disabled") } - if meta.Shared.CustomObjectName != "" { + if meta.Remote.CustomObjectName != "" { return fmt.Sprintf( - "%s.ref.%d.%06d", meta.Shared.CustomObjectName, refCreatorID, refFileNum.FileNum(), + "%s.ref.%d.%06d", meta.Remote.CustomObjectName, refCreatorID, refFileNum.FileNum(), ) } switch meta.FileType { case base.FileTypeTable: return fmt.Sprintf( "%04x-%d-%06d.sst.ref.%d.%06d", - objHash(meta), meta.Shared.CreatorID, meta.Shared.CreatorFileNum.FileNum(), refCreatorID, refFileNum.FileNum(), + objHash(meta), meta.Remote.CreatorID, meta.Remote.CreatorFileNum.FileNum(), refCreatorID, refFileNum.FileNum(), ) } panic("unknown FileType") } func sharedObjectRefPrefix(meta objstorage.ObjectMetadata) string { - if meta.Shared.CustomObjectName != "" { - return meta.Shared.CustomObjectName + ".ref." + if meta.Remote.CustomObjectName != "" { + return meta.Remote.CustomObjectName + ".ref." } switch meta.FileType { case base.FileTypeTable: return fmt.Sprintf( "%04x-%d-%06d.sst.ref.", - objHash(meta), meta.Shared.CreatorID, meta.Shared.CreatorFileNum.FileNum(), + objHash(meta), meta.Remote.CreatorID, meta.Remote.CreatorFileNum.FileNum(), ) } panic("unknown FileType") @@ -75,7 +75,7 @@ func sharedObjectRefPrefix(meta objstorage.ObjectMetadata) string { // // For example: 1a3f-2-000001.sst.ref.5.000008 func (p *provider) sharedObjectRefName(meta objstorage.ObjectMetadata) string { - if meta.Shared.CleanupMethod != objstorage.SharedRefTracking { + if meta.Remote.CleanupMethod != objstorage.SharedRefTracking { panic("ref object used when ref tracking disabled") } return sharedObjectRefName(meta, p.shared.creatorID, meta.DiskFileNum) @@ -87,5 +87,5 @@ func (p *provider) sharedObjectRefName(meta objstorage.ObjectMetadata) string { func objHash(meta objstorage.ObjectMetadata) uint16 { const prime1 = 7459 const prime2 = 17539 - return uint16(uint64(meta.Shared.CreatorID)*prime1 + uint64(meta.Shared.CreatorFileNum.FileNum())*prime2) + return uint16(uint64(meta.Remote.CreatorID)*prime1 + uint64(meta.Remote.CreatorFileNum.FileNum())*prime2) } diff --git a/objstorage/objstorageprovider/shared_obj_name_test.go b/objstorage/objstorageprovider/shared_obj_name_test.go index f946fa2069..2af201c58e 100644 --- a/objstorage/objstorageprovider/shared_obj_name_test.go +++ b/objstorage/objstorageprovider/shared_obj_name_test.go @@ -23,17 +23,17 @@ func TestSharedObjectNames(t *testing.T) { var meta objstorage.ObjectMetadata meta.DiskFileNum = base.FileNum(rand.Intn(100000)).DiskFileNum() meta.FileType = supportedFileTypes[rand.Int()%len(supportedFileTypes)] - meta.Shared.CreatorID = objstorage.CreatorID(rand.Int63()) - meta.Shared.CreatorFileNum = base.FileNum(rand.Intn(100000)).DiskFileNum() + meta.Remote.CreatorID = objstorage.CreatorID(rand.Int63()) + meta.Remote.CreatorFileNum = base.FileNum(rand.Intn(100000)).DiskFileNum() if rand.Intn(4) == 0 { - meta.Shared.CustomObjectName = fmt.Sprintf("foo-%d.sst", rand.Intn(10000)) + meta.Remote.CustomObjectName = fmt.Sprintf("foo-%d.sst", rand.Intn(10000)) } obj := sharedObjectName(meta) // Cross-check against cleaner implementations. - expObj := meta.Shared.CustomObjectName + expObj := meta.Remote.CustomObjectName if expObj == "" { - expObj = fmt.Sprintf("%04x-%s-%s", objHash(meta), meta.Shared.CreatorID, base.MakeFilename(meta.FileType, meta.Shared.CreatorFileNum)) + expObj = fmt.Sprintf("%04x-%s-%s", objHash(meta), meta.Remote.CreatorID, base.MakeFilename(meta.FileType, meta.Remote.CreatorFileNum)) } require.Equal(t, expObj, obj) @@ -50,8 +50,8 @@ func TestSharedObjectNames(t *testing.T) { var meta objstorage.ObjectMetadata meta.DiskFileNum = base.FileNum(123).DiskFileNum() meta.FileType = base.FileTypeTable - meta.Shared.CreatorID = objstorage.CreatorID(456) - meta.Shared.CreatorFileNum = base.FileNum(789).DiskFileNum() + meta.Remote.CreatorID = objstorage.CreatorID(456) + meta.Remote.CreatorFileNum = base.FileNum(789).DiskFileNum() require.Equal(t, sharedObjectName(meta), "0e17-456-000789.sst") require.Equal(t, sharedObjectRefPrefix(meta), "0e17-456-000789.sst.ref.") diff --git a/objstorage/shared/storage.go b/objstorage/shared/storage.go index 59a08b509b..2e96c5aaad 100644 --- a/objstorage/shared/storage.go +++ b/objstorage/shared/storage.go @@ -13,7 +13,7 @@ import ( // // The Locator must not contain secrets (like authentication keys). Locators are // stored on disk in the shared object catalog and are passed around as part of -// SharedObjectBacking; they can also appear in error messages. +// RemoteObjectBacking; they can also appear in error messages. type Locator string // StorageFactory is used to return Storage implementations based on locators. A diff --git a/open.go b/open.go index 38293e8ae7..1518a92872 100644 --- a/open.go +++ b/open.go @@ -814,7 +814,7 @@ func (d *DB) replayWAL( if err != nil { return nil, 0, errors.Wrap(err, "pebble: error when looking up ingested SSTs") } - if objMeta.IsShared() { + if objMeta.IsRemote() { readable, err = d.objProvider.OpenForReading(context.TODO(), fileTypeTable, n, objstorage.OpenOptions{MustExist: true}) if err != nil { return nil, 0, errors.Wrap(err, "pebble: error when opening flushable ingest files") diff --git a/scan_internal.go b/scan_internal.go index 28fbb2be2a..6bd075e8e1 100644 --- a/scan_internal.go +++ b/scan_internal.go @@ -45,7 +45,7 @@ var ErrInvalidSkipSharedIteration = errors.New("pebble: cannot use skip-shared i type SharedSSTMeta struct { // Backing is the shared object underlying this SST. Can be attached to an // objstorage.Provider. - Backing objstorage.SharedObjectBackingHandle + Backing objstorage.RemoteObjectBackingHandle // Smallest and Largest internal keys for the overall bounds. The kind and // SeqNum of these will reflect what is physically present on the source Pebble @@ -725,7 +725,7 @@ func (d *DB) truncateSharedFile( sst = &SharedSSTMeta{} sst.cloneFromFileMeta(file) sst.Level = uint8(level) - sst.Backing, err = d.objProvider.SharedObjectBacking(&objMeta) + sst.Backing, err = d.objProvider.RemoteObjectBacking(&objMeta) if err != nil { return nil, false, err }