kvclient: make cacheEntry private

CacheEntry is not intended to be exposed externally. This commit makes
it a private type in the RangeCache.

Epic: none

Release note: None

Author: andrewbaptist

pkg/kv/kvclient/rangecache/range_cache.go

@@ -94,7 +94,7 @@ const (
 	ReadFromLeaseholder = kvpb.READ_UNCOMMITTED
 )
 
-// UnknownClosedTimestampPolicy is used to mark on a CacheEntry that the closed
+// UnknownClosedTimestampPolicy is used to mark on a cacheEntry that the closed
 // timestamp policy is not known. This value is never serialized into
 // RangeInfo or any other message which uses the type.
 const UnknownClosedTimestampPolicy roachpb.RangeClosedTimestampPolicy = -1
@@ -275,18 +275,18 @@ type EvictionToken struct {
 	// compatible descriptor, with the same range id and key bounds. If the
 	// descriptor changes in a non-compatible way, this EvictionToken must be
 	// discarded and a new one retrieved from the RangeCache.
-	entry *CacheEntry
+	entry *cacheEntry
 }
 
-func (rc *RangeCache) makeEvictionToken(entry *CacheEntry) EvictionToken {
+func (rc *RangeCache) makeEvictionToken(entry *cacheEntry) EvictionToken {
 	return EvictionToken{
 		rdc:   rc,
 		entry: entry,
 	}
 }
 
 // MakeEvictionToken is the exported ctor. For tests only.
-func (rc *RangeCache) MakeEvictionToken(entry *CacheEntry) EvictionToken {
+func (rc *RangeCache) MakeEvictionToken(entry *cacheEntry) EvictionToken {
 	return rc.makeEvictionToken(entry)
 }
 
@@ -375,7 +375,7 @@ func (et EvictionToken) ClosedTimestampPolicy(
 // entry for the start key any more.
 func (et *EvictionToken) syncRLocked(
 	ctx context.Context,
-) (stillValid bool, cachedEntry *CacheEntry, rawEntry *cache.Entry) {
+) (stillValid bool, cachedEntry *cacheEntry, rawEntry *cache.Entry) {
 	cachedEntry, rawEntry = et.rdc.getCachedRLocked(ctx, et.entry.desc.StartKey, false /* inverted */)
 	if cachedEntry == nil || !descsCompatible(cachedEntry.Desc(), et.Desc()) {
 		et.clear()
@@ -622,11 +622,11 @@ func (rc *RangeCache) Lookup(ctx context.Context, key roachpb.RKey) (roachpb.Ran
 
 // GetCachedOverlapping returns all the cached entries which overlap a given
 // span [Key, EndKey). The results are sorted ascendingly.
-func (rc *RangeCache) GetCachedOverlapping(ctx context.Context, span roachpb.RSpan) []*CacheEntry {
+func (rc *RangeCache) GetCachedOverlapping(ctx context.Context, span roachpb.RSpan) []*cacheEntry {
 	rc.rangeCache.RLock()
 	defer rc.rangeCache.RUnlock()
 	rawEntries := rc.getCachedOverlappingRLocked(ctx, span)
-	entries := make([]*CacheEntry, len(rawEntries))
+	entries := make([]*cacheEntry, len(rawEntries))
 	for i, e := range rawEntries {
 		entries[i] = rc.getValue(e)
 	}
@@ -906,10 +906,10 @@ func tryLookupImpl(
 	rc.rangeCache.Lock()
 	defer rc.rangeCache.Unlock()
 
-	// We want to insert a new CacheEntry, possibly with a speculativeDesc.
+	// We want to insert a new cacheEntry, possibly with a speculativeDesc.
 	// Create the entry based on the lookup and try and insert it into the
 	// cache.
-	newEntry := CacheEntry{
+	newEntry := cacheEntry{
 		desc: rs[0],
 		// We don't have any lease information.
 		lease: roachpb.Lease{},
@@ -930,10 +930,10 @@ func tryLookupImpl(
 	// rs[0]'s eviction token. Note that ranges for which the cache has more
 	// up-to-date information will not be clobbered - for example ranges for
 	// which the cache has the prefetched descriptor already plus a lease.
-	newEntries := make([]*CacheEntry, len(preRs)+1)
+	newEntries := make([]*cacheEntry, len(preRs)+1)
 	newEntries[0] = &newEntry
 	for i, preR := range preRs {
-		newEntries[i+1] = &CacheEntry{desc: preR, closedts: UnknownClosedTimestampPolicy}
+		newEntries[i+1] = &cacheEntry{desc: preR, closedts: UnknownClosedTimestampPolicy}
 	}
 	insertedEntries := rc.insertLockedInner(ctx, newEntries)
 	// entry corresponds to rs[0], which is the descriptor covering the key
@@ -1051,7 +1051,7 @@ func (rc *RangeCache) TestingGetCached(
 // used for descriptor eviction.
 func (rc *RangeCache) getCachedRLocked(
 	ctx context.Context, key roachpb.RKey, inverted bool,
-) (*CacheEntry, *cache.Entry) {
+) (*cacheEntry, *cache.Entry) {
 	// rawEntry will be the range containing key, or the first cached entry around
 	// key, in the direction indicated by inverted.
 	var rawEntry *cache.Entry
@@ -1117,10 +1117,10 @@ func (rc *RangeCache) Insert(ctx context.Context, rs ...roachpb.RangeInfo) {
 // for putting in eviction tokens. Any element in the returned array can be nil
 // if inserting the respective RangeInfo failed because it was found to be
 // stale.
-func (rc *RangeCache) insertLocked(ctx context.Context, rs ...roachpb.RangeInfo) []*CacheEntry {
-	entries := make([]*CacheEntry, len(rs))
+func (rc *RangeCache) insertLocked(ctx context.Context, rs ...roachpb.RangeInfo) []*cacheEntry {
+	entries := make([]*cacheEntry, len(rs))
 	for i, r := range rs {
-		entries[i] = &CacheEntry{
+		entries[i] = &cacheEntry{
 			desc:     r.Desc,
 			lease:    r.Lease,
 			closedts: r.ClosedTimestampPolicy,
@@ -1129,10 +1129,10 @@ func (rc *RangeCache) insertLocked(ctx context.Context, rs ...roachpb.RangeInfo)
 	return rc.insertLockedInner(ctx, entries)
 }
 
-func (rc *RangeCache) insertLockedInner(ctx context.Context, rs []*CacheEntry) []*CacheEntry {
+func (rc *RangeCache) insertLockedInner(ctx context.Context, rs []*cacheEntry) []*cacheEntry {
 	// entries will have the same element as rs, except the ones that couldn't be
 	// inserted for which the slots will remain nil.
-	entries := make([]*CacheEntry, len(rs))
+	entries := make([]*cacheEntry, len(rs))
 	for i, ent := range rs {
 		if !ent.desc.IsInitialized() {
 			log.Fatalf(ctx, "inserting uninitialized desc: %s", ent)
@@ -1170,13 +1170,13 @@ func (rc *RangeCache) insertLockedInner(ctx context.Context, rs []*CacheEntry) [
 	return entries
 }
 
-func (rc *RangeCache) getValue(entry *cache.Entry) *CacheEntry {
-	return entry.Value.(*CacheEntry)
+func (rc *RangeCache) getValue(entry *cache.Entry) *cacheEntry {
+	return entry.Value.(*cacheEntry)
 }
 
 func (rc *RangeCache) clearOlderOverlapping(
-	ctx context.Context, newEntry *CacheEntry,
-) (ok bool, newerEntry *CacheEntry) {
+	ctx context.Context, newEntry *cacheEntry,
+) (ok bool, newerEntry *cacheEntry) {
 	rc.rangeCache.Lock()
 	defer rc.rangeCache.Unlock()
 	return rc.clearOlderOverlappingLocked(ctx, newEntry)
@@ -1193,11 +1193,11 @@ func (rc *RangeCache) clearOlderOverlapping(
 // Note that even if false is returned, older descriptors are still cleared from
 // the cache.
 func (rc *RangeCache) clearOlderOverlappingLocked(
-	ctx context.Context, newEntry *CacheEntry,
-) (ok bool, newerEntry *CacheEntry) {
+	ctx context.Context, newEntry *cacheEntry,
+) (ok bool, newerEntry *cacheEntry) {
 	log.VEventf(ctx, 2, "clearing entries overlapping %s", newEntry.Desc())
 	newest := true
-	var newerFound *CacheEntry
+	var newerFound *cacheEntry
 	overlapping := rc.getCachedOverlappingRLocked(ctx, newEntry.Desc().RSpan())
 	for _, e := range overlapping {
 		entry := rc.getValue(e)
@@ -1226,7 +1226,7 @@ func (rc *RangeCache) clearOlderOverlappingLocked(
 // swapEntryLocked swaps oldEntry for newEntry. If newEntry is nil, oldEntry is
 // simply removed.
 func (rc *RangeCache) swapEntryLocked(
-	ctx context.Context, oldEntry *cache.Entry, newEntry *CacheEntry,
+	ctx context.Context, oldEntry *cache.Entry, newEntry *cacheEntry,
 ) {
 	if newEntry != nil {
 		old := rc.getValue(oldEntry)
@@ -1243,7 +1243,7 @@ func (rc *RangeCache) swapEntryLocked(
 	}
 }
 
-func (rc *RangeCache) addEntryLocked(entry *CacheEntry) {
+func (rc *RangeCache) addEntryLocked(entry *cacheEntry) {
 	key := newRangeCacheKey(entry.Desc().StartKey)
 	rc.rangeCache.cache.Add(key, entry)
 }
@@ -1269,12 +1269,12 @@ func (rc *RangeCache) NumInFlight(name string) int {
 	return rc.lookupRequests.NumCalls(name)
 }
 
-// CacheEntry represents one cache entry.
+// cacheEntry represents one cache entry.
 //
-// The cache stores *CacheEntry. Entries are immutable: cache lookups
-// returns the same *CacheEntry to multiple queriers for efficiency, but
+// The cache stores *cacheEntry. Entries are immutable: cache lookups
+// returns the same *cacheEntry to multiple queriers for efficiency, but
 // nobody should modify the lookup result.
-type CacheEntry struct {
+type cacheEntry struct {
 	// desc is always populated.
 	desc roachpb.RangeDescriptor
 	// speculativeDesc, if not nil, is the descriptor that should replace desc if
@@ -1300,20 +1300,20 @@ type CacheEntry struct {
 	closedts roachpb.RangeClosedTimestampPolicy
 }
 
-func (e CacheEntry) String() string {
+func (e cacheEntry) String() string {
 	return fmt.Sprintf("desc:%s, lease:%s", e.Desc(), e.lease)
 }
 
 // Desc returns the cached descriptor. Note that, besides being possibly stale,
 // this descriptor also might not represent a descriptor that was ever
 // committed. See DescSpeculative().
-func (e *CacheEntry) Desc() *roachpb.RangeDescriptor {
+func (e *cacheEntry) Desc() *roachpb.RangeDescriptor {
 	return &e.desc
 }
 
 // Leaseholder returns the cached leaseholder replica, if known. Returns nil if
 // the leaseholder is not known.
-func (e *CacheEntry) Leaseholder() *roachpb.ReplicaDescriptor {
+func (e *cacheEntry) Leaseholder() *roachpb.ReplicaDescriptor {
 	if e.lease.Empty() {
 		return nil
 	}
@@ -1323,7 +1323,7 @@ func (e *CacheEntry) Leaseholder() *roachpb.ReplicaDescriptor {
 // Lease returns the cached lease, if known. Returns nil if no lease is known.
 // It's possible for a leaseholder to be known, but not a full lease, in which
 // case Leaseholder() returns non-nil but Lease() returns nil.
-func (e *CacheEntry) Lease() *roachpb.Lease {
+func (e *cacheEntry) Lease() *roachpb.Lease {
 	if e.lease.Empty() {
 		return nil
 	}
@@ -1335,7 +1335,7 @@ func (e *CacheEntry) Lease() *roachpb.Lease {
 
 // ClosedTimestampPolicy returns the cached understanding of the range's closed
 // timestamp policy. If no policy is known, LAG_BY_CLUSTER_SETTING is returned.
-func (e *CacheEntry) ClosedTimestampPolicy() roachpb.RangeClosedTimestampPolicy {
+func (e *cacheEntry) ClosedTimestampPolicy() roachpb.RangeClosedTimestampPolicy {
 	return e.closedts
 }
 
@@ -1344,21 +1344,21 @@ func (e *CacheEntry) ClosedTimestampPolicy() roachpb.RangeClosedTimestampPolicy
 // inserted in the cache with Generation=0.
 //
 // Speculative descriptors come from (not-yet-committed) intents.
-func (e *CacheEntry) DescSpeculative() bool {
+func (e *cacheEntry) DescSpeculative() bool {
 	return e.desc.Generation == 0
 }
 
 // LeaseSpeculative returns true if the lease in the entry is "speculative"
 // - i.e. it doesn't correspond to a committed lease. Such leases have been
 // inserted in the cache with Sequence=0.
-func (e *CacheEntry) LeaseSpeculative() bool {
+func (e *cacheEntry) LeaseSpeculative() bool {
 	if e.lease.Empty() {
 		panic(fmt.Sprintf("LeaseSpeculative called on entry with empty lease: %s", e))
 	}
 	return e.lease.Speculative()
 }
 
-func (e *CacheEntry) toRangeInfo() roachpb.RangeInfo {
+func (e *cacheEntry) toRangeInfo() roachpb.RangeInfo {
 	return roachpb.RangeInfo{
 		Desc:                  e.desc,
 		Lease:                 e.lease,
@@ -1379,7 +1379,7 @@ func (e *CacheEntry) toRangeInfo() roachpb.RangeInfo {
 // can't be determined what information is newer is when at least one of the
 // descriptors is "speculative" (generation=0), or when the lease information is
 // "speculative" (sequence=0).
-func (e *CacheEntry) overrides(o *CacheEntry) bool {
+func (e *cacheEntry) overrides(o *cacheEntry) bool {
 	if util.RaceEnabled {
 		if _, err := e.Desc().RSpan().Intersect(o.Desc().RSpan()); err != nil {
 			panic(fmt.Sprintf("descriptors don't intersect: %s vs %s", e.Desc(), o.Desc()))
@@ -1419,7 +1419,7 @@ func (e *CacheEntry) overrides(o *CacheEntry) bool {
 //
 // In case at least one of the descriptors is "speculative", a is considered
 // older; this matches the semantics of b.overrides(a).
-func compareEntryDescs(a, b *CacheEntry) int {
+func compareEntryDescs(a, b *cacheEntry) int {
 	if util.RaceEnabled {
 		if _, err := a.Desc().RSpan().Intersect(b.Desc().RSpan()); err != nil {
 			panic(fmt.Sprintf("descriptors don't intersect: %s vs %s", a.Desc(), b.Desc()))
@@ -1450,7 +1450,7 @@ func compareEntryDescs(a, b *CacheEntry) int {
 // An empty lease is considered older than any other. In case at least one of
 // the leases is "speculative", a is considered older; this matches the
 // semantics of b.overrides(a).
-func compareEntryLeases(a, b *CacheEntry) int {
+func compareEntryLeases(a, b *cacheEntry) int {
 	if aEmpty, bEmpty := a.lease.Empty(), b.lease.Empty(); aEmpty || bEmpty {
 		if aEmpty && !bEmpty {
 			return -1
@@ -1476,7 +1476,7 @@ func compareEntryLeases(a, b *CacheEntry) int {
 	return 0
 }
 
-// maybeUpdate returns a new CacheEntry which contains the freshest lease/range
+// maybeUpdate returns a new cacheEntry which contains the freshest lease/range
 // descriptor by comparing the receiver's fields to the passed-in parameters.
 //
 // The updated retval indicates if either the passed-in lease or the range
@@ -1499,15 +1499,15 @@ func compareEntryLeases(a, b *CacheEntry) int {
 //
 // It's expected that the supplied rangeDesc is compatible with the descriptor
 // on the cache entry.
-func (e *CacheEntry) maybeUpdate(
+func (e *cacheEntry) maybeUpdate(
 	ctx context.Context, l *roachpb.Lease, rangeDesc *roachpb.RangeDescriptor,
-) (updated, updatedLease bool, newEntry *CacheEntry) {
+) (updated, updatedLease bool, newEntry *cacheEntry) {
 	if !descsCompatible(e.Desc(), rangeDesc) {
 		log.Fatalf(ctx, "attempting to update by comparing non-compatible descs: %s vs %s",
 			e.Desc(), rangeDesc)
 	}
 
-	newEntry = &CacheEntry{
+	newEntry = &cacheEntry{
 		lease:    e.lease,
 		desc:     e.desc,
 		closedts: e.closedts,
@@ -1571,13 +1571,13 @@ func (e *CacheEntry) maybeUpdate(
 	return updatedLease || updatedDesc, updatedLease, newEntry
 }
 
-func (e *CacheEntry) evictLeaseholder(
+func (e *cacheEntry) evictLeaseholder(
 	lh roachpb.ReplicaDescriptor,
-) (updated bool, newEntry *CacheEntry) {
+) (updated bool, newEntry *cacheEntry) {
 	if e.lease.Replica != lh {
 		return false, e
 	}
-	return true, &CacheEntry{
+	return true, &cacheEntry{
 		desc:     e.desc,
 		closedts: e.closedts,
 	}