objstorage: rename Shared to Remote in the objstorage provider API

`IsShared()` is split into `IsRemote()`, `IsShared()`, `IsExternal()`.

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

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
 					}
 				}

ingest.go

@@ -449,32 +449,32 @@ func ingestLink(
 			})
 		}
 	}
-	sharedObjs := make([]objstorage.SharedObjectToAttach, 0, len(shared))
+	remoteObjs := 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{
+		remoteObjs = append(remoteObjs, objstorage.RemoteObjectToAttach{
 			FileNum:  lr.sharedMeta[i].FileBacking.DiskFileNum,
 			FileType: fileTypeTable,
 			Backing:  backing,
 		})
 	}
-	sharedObjMetas, err := objProvider.AttachSharedObjects(sharedObjs)
+	remoteObjMetas, err := objProvider.AttachSharedObjects(remoteObjs)
 	if err != nil {
 		return err
 	}
-	for i := range sharedObjMetas {
+	for i := range remoteObjMetas {
 		// One corner case around file sizes we need to be mindful of, is that
 		// if one of the shareObjs was initially created by us (and has boomeranged
 		// back from another node), we'll need to update the FileBacking's size
 		// to be the true underlying size. Otherwise, we could hit errors when we
 		// 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]) {
-			size, err := objProvider.Size(sharedObjMetas[i])
+		if remoteObjMetas[i].IsShared() && !objProvider.IsForeign(remoteObjMetas[i]) {
+			size, err := objProvider.Size(remoteObjMetas[i])
 			if err != nil {
 				return err
 			}
@@ -484,7 +484,7 @@ func ingestLink(
 			opts.EventListener.TableCreated(TableCreateInfo{
 				JobID:   jobID,
 				Reason:  "ingesting",
-				Path:    objProvider.Path(sharedObjMetas[i]),
+				Path:    objProvider.Path(remoteObjMetas[i]),
 				FileNum: lr.sharedMeta[i].FileNum,
 			})
 		}
@@ -858,7 +858,7 @@ func ingestTargetLevel(
 //     local sstables. This is the step where overlap with memtables is
 //     determined. If there is overlap, we remember the most recent memtable
 //     that overlaps.
-//  6. Update the sequence number in the ingested local sstables. (Shared
+//  6. Update the sequence number in the ingested local sstables. (Remote
 //     sstables get fixed sequence numbers that were determined at load time.)
 //  7. Wait for the most recent memtable that overlaps to flush (if any).
 //  8. Add the ingested sstables to the version (DB.ingestApply).
@@ -1295,7 +1295,7 @@ func (d *DB) ingest(
 		}
 	}
 
-	// NB: Shared-sstable-only ingestions do not assign a sequence number to
+	// NB: Remote-sstable-only ingestions do not assign a sequence number to
 	// any sstables.
 	globalSeqNum := uint64(0)
 	if len(loadResult.localMeta) > 0 {

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,43 @@ 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 not owned by
+// a Pebble instances in the cluster.
 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 +173,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 +261,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 +272,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 shared object metadata for the given object.
+	SharedObjectBacking(meta *ObjectMetadata) (RemoteObjectBackingHandle, error)
 
 	// CreateSharedObjectBacking 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)
+	CreateSharedObjectBacking(locator shared.Locator, objName string) (RemoteObjectBacking, error)
 
 	// AttachSharedObjects registers existing shared objects with this provider.
-	AttachSharedObjects(objs []SharedObjectToAttach) ([]ObjectMetadata, error)
+	AttachSharedObjects(objs []RemoteObjectToAttach) ([]ObjectMetadata, error)
 
 	Close() error
 
@@ -278,31 +290,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 remote
 // 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
 }

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,15 +411,15 @@ 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)
 }
 
 // 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