func doLookup(t *testing.T, rc *RangeDescriptorCache, key string) {
r, err := rc.LookupRangeDescriptor(proto.Key(key))
if err != nil {
t.Fatalf("Unexpected error from LookupRangeDescriptor: %s", err.Error())
}
if !r.ContainsKey(engine.KeyAddress(proto.Key(key))) {
t.Fatalf("Returned range did not contain key: %s-%s, %s", r.StartKey, r.EndKey, key)
}
}
// maybeBeginTxn begins a new transaction if a txn has been specified
// in the request but has a nil ID. The new transaction is initialized
// using the name and isolation in the otherwise uninitialized txn.
// The Priority, if non-zero is used as a minimum.
func (tc *TxnCoordSender) maybeBeginTxn(header *proto.RequestHeader) {
if header.Txn != nil {
if len(header.Txn.ID) == 0 {
newTxn := proto.NewTransaction(header.Txn.Name, engine.KeyAddress(header.Key), header.GetUserPriority(),
header.Txn.Isolation, tc.clock.Now(), tc.clock.MaxOffset().Nanoseconds())
// Use existing priority as a minimum. This is used on transaction
// aborts to ratchet priority when creating successor transaction.
if newTxn.Priority < header.Txn.Priority {
newTxn.Priority = header.Txn.Priority
}
header.Txn = newTxn
}
}
}
// getCachedRangeDescriptor is a helper function to retrieve the
// descriptor of the range which contains the given key, if present in
// the cache.
func (rmc *RangeDescriptorCache) getCachedRangeDescriptor(key proto.Key) (
rangeCacheKey, *proto.RangeDescriptor) {
metaKey := engine.RangeMetaKey(key)
rmc.rangeCacheMu.RLock()
defer rmc.rangeCacheMu.RUnlock()
k, v, ok := rmc.rangeCache.Ceil(rangeCacheKey(metaKey))
if !ok {
return nil, nil
}
metaEndKey := k.(rangeCacheKey)
rd := v.(*proto.RangeDescriptor)
// Check that key actually belongs to range
if !rd.ContainsKey(engine.KeyAddress(key)) {
return nil, nil
}
return metaEndKey, rd
}