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 }