本文整理汇总了Golang中github.com/cockroachdb/cockroach/proto.Key函数的典型用法代码示例。如果您正苦于以下问题:Golang Key函数的具体用法?Golang Key怎么用?Golang Key使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Key函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: compareBiogoNode
// compareBiogoNode compares a biogo node and a range tree node to determine if both
// contain the same values in the same order. It recursively calls itself on
// both children if they exist.
func compareBiogoNode(db *client.DB, biogoNode *llrb.Node, key *proto.Key) error {
// Retrieve the node form the range tree.
rtNode := &proto.RangeTreeNode{}
if err := db.GetProto(keys.RangeTreeNodeKey(*key), rtNode); err != nil {
return err
}
bNode := &proto.RangeTreeNode{
Key: proto.Key(biogoNode.Elem.(Key)),
ParentKey: proto.KeyMin,
Black: bool(biogoNode.Color),
}
if biogoNode.Left != nil {
leftKey := proto.Key(biogoNode.Left.Elem.(Key))
bNode.LeftKey = &leftKey
}
if biogoNode.Right != nil {
rightKey := proto.Key(biogoNode.Right.Elem.(Key))
bNode.RightKey = &rightKey
}
if err := nodesEqual(*key, *bNode, *rtNode); err != nil {
return err
}
if rtNode.LeftKey != nil {
if err := compareBiogoNode(db, biogoNode.Left, rtNode.LeftKey); err != nil {
return err
}
}
if rtNode.RightKey != nil {
if err := compareBiogoNode(db, biogoNode.Right, rtNode.RightKey); err != nil {
return err
}
}
return nil
}
示例2: TestGetFirstRangeDescriptor
func TestGetFirstRangeDescriptor(t *testing.T) {
n := simulation.NewNetwork(3, "unix", gossip.TestInterval, gossip.TestBootstrap)
ds := NewDistSender(n.Nodes[0].Gossip)
if _, err := ds.getFirstRangeDescriptor(); err == nil {
t.Errorf("expected not to find first range descriptor")
}
expectedDesc := &proto.RangeDescriptor{}
expectedDesc.StartKey = proto.Key("a")
expectedDesc.EndKey = proto.Key("c")
// Add first RangeDescriptor to a node different from the node for
// this dist sender and ensure that this dist sender has the
// information within a given time.
n.Nodes[1].Gossip.AddInfo(
gossip.KeyFirstRangeDescriptor, *expectedDesc, time.Hour)
maxCycles := 10
n.SimulateNetwork(func(cycle int, network *simulation.Network) bool {
desc, err := ds.getFirstRangeDescriptor()
if err != nil {
if cycle >= maxCycles {
t.Errorf("could not get range descriptor after %d cycles", cycle)
return false
}
return true
}
if !bytes.Equal(desc.StartKey, expectedDesc.StartKey) ||
!bytes.Equal(desc.EndKey, expectedDesc.EndKey) {
t.Errorf("expected first range descriptor %v, instead was %v",
expectedDesc, desc)
}
return false
})
n.Stop()
}
示例3: TestTxnCoordSenderEndTxn
// TestTxnCoordSenderEndTxn verifies that ending a transaction
// sends resolve write intent requests and removes the transaction
// from the txns map.
func TestTxnCoordSenderEndTxn(t *testing.T) {
defer leaktest.AfterTest(t)
s := createTestDB(t)
defer s.Stop()
txn := newTxn(s.Clock, proto.Key("a"))
key := proto.Key("a")
put := createPutRequest(key, []byte("value"), txn)
reply, err := batchutil.SendWrapped(s.Sender, put)
if err != nil {
t.Fatal(err)
}
pReply := reply.(*proto.PutResponse)
if _, err := batchutil.SendWrapped(s.Sender, &proto.EndTransactionRequest{
RequestHeader: proto.RequestHeader{
Key: txn.Key,
Timestamp: txn.Timestamp,
Txn: pReply.Header().Txn,
},
Commit: true,
}); err != nil {
t.Fatal(err)
}
verifyCleanup(key, s.Sender, s.Eng, t)
}
示例4: TestRangeSplit
// TestRangeSplit executes various splits and checks that all created intents
// are resolved. This includes both intents which are resolved synchronously
// with EndTransaction and via RPC.
func TestRangeSplit(t *testing.T) {
defer leaktest.AfterTest(t)
s := createTestDB(t)
defer s.Stop()
splitKeys := []proto.Key{proto.Key("G"), keys.RangeMetaKey(proto.Key("F")),
keys.RangeMetaKey(proto.Key("K")), keys.RangeMetaKey(proto.Key("H"))}
// Execute the consecutive splits.
for _, splitKey := range splitKeys {
log.Infof("starting split at key %q...", splitKey)
if err := s.DB.AdminSplit(splitKey); err != nil {
t.Fatal(err)
}
log.Infof("split at key %q complete", splitKey)
}
if err := util.IsTrueWithin(func() bool {
if _, _, err := engine.MVCCScan(s.Eng, keys.LocalMax, proto.KeyMax, 0, proto.MaxTimestamp, true, nil); err != nil {
log.Infof("mvcc scan should be clean: %s", err)
return false
}
return true
}, 500*time.Millisecond); err != nil {
t.Error("failed to verify no dangling intents within 500ms")
}
}
示例5: Example_rmUsers
// Example_rmUsers creates a series of user configs and verifies
// user-rm works by deleting some and then all and verifying entries
// have been removed via user-ls. Also verify the default user config
// cannot be removed.
func Example_rmUsers() {
_, stopper := startAdminServer()
defer stopper.Stop()
keys := []proto.Key{
proto.Key("user1"),
proto.Key("user2"),
}
for _, key := range keys {
prefix := url.QueryEscape(string(key))
RunSetUser(testContext, prefix, testUserConfigBytes)
}
for _, key := range keys {
prefix := url.QueryEscape(string(key))
RunRmUser(testContext, prefix)
RunLsUser(testContext, "")
}
// Output:
// set user config for key prefix "user1"
// set user config for key prefix "user2"
// removed user config for key prefix "user1"
// [default]
// user2
// removed user config for key prefix "user2"
// [default]
}
示例6: TestMetaScanBounds
func TestMetaScanBounds(t *testing.T) {
defer leaktest.AfterTest(t)
testCases := []struct {
key, expStart, expEnd proto.Key
}{
{
key: proto.Key{},
expStart: Meta1Prefix,
expEnd: Meta1Prefix.PrefixEnd(),
},
{
key: proto.Key("foo"),
expStart: proto.Key("foo").Next(),
expEnd: proto.Key("foo")[:len(Meta1Prefix)].PrefixEnd(),
},
{
key: proto.MakeKey(Meta1Prefix, proto.KeyMax),
expStart: proto.MakeKey(Meta1Prefix, proto.KeyMax),
expEnd: Meta1Prefix.PrefixEnd(),
},
}
for i, test := range testCases {
resStart, resEnd := MetaScanBounds(test.key)
if !resStart.Equal(test.expStart) || !resEnd.Equal(test.expEnd) {
t.Errorf("%d: range bounds %q-%q don't match expected bounds %q-%q for key %q", i, resStart, resEnd, test.expStart, test.expEnd, test.key)
}
}
}
示例7: TestTxnCoordSenderGC
// TestTxnCoordSenderGC verifies that the coordinator cleans up extant
// transactions after the lastUpdateNanos exceeds the timeout.
func TestTxnCoordSenderGC(t *testing.T) {
defer leaktest.AfterTest(t)
s := createTestDB(t)
defer s.Stop()
// Set heartbeat interval to 1ms for testing.
s.Sender.heartbeatInterval = 1 * time.Millisecond
txn := newTxn(s.Clock, proto.Key("a"))
call := proto.Call{
Args: createPutRequest(proto.Key("a"), []byte("value"), txn),
Reply: &proto.PutResponse{},
}
if err := sendCall(s.Sender, call); err != nil {
t.Fatal(err)
}
// Now, advance clock past the default client timeout.
// Locking the TxnCoordSender to prevent a data race.
s.Sender.Lock()
s.Manual.Set(defaultClientTimeout.Nanoseconds() + 1)
s.Sender.Unlock()
if err := util.IsTrueWithin(func() bool {
// Locking the TxnCoordSender to prevent a data race.
s.Sender.Lock()
_, ok := s.Sender.txns[string(txn.ID)]
s.Sender.Unlock()
return !ok
}, 50*time.Millisecond); err != nil {
t.Error("expected garbage collection")
}
}
示例8: TestSendRPCRetry
// TestSendRPCRetry verifies that sendRPC failed on first address but succeed on
// second address, the second reply should be successfully returned back.
func TestSendRPCRetry(t *testing.T) {
defer leaktest.AfterTest(t)
g, s := makeTestGossip(t)
defer s()
if err := g.SetNodeDescriptor(&proto.NodeDescriptor{NodeID: 1}); err != nil {
t.Fatal(err)
}
// Fill RangeDescriptor with 2 replicas
var descriptor = proto.RangeDescriptor{
RaftID: 1,
StartKey: proto.Key("a"),
EndKey: proto.Key("z"),
}
for i := 1; i <= 2; i++ {
addr := util.MakeUnresolvedAddr("tcp", fmt.Sprintf("node%d", i))
nd := &proto.NodeDescriptor{
NodeID: proto.NodeID(i),
Address: proto.Addr{
Network: addr.Network(),
Address: addr.String(),
},
}
if err := g.AddInfo(gossip.MakeNodeIDKey(proto.NodeID(i)), nd, time.Hour); err != nil {
t.Fatal(err)
}
descriptor.Replicas = append(descriptor.Replicas, proto.Replica{
NodeID: proto.NodeID(i),
StoreID: proto.StoreID(i),
})
}
// Define our rpcSend stub which returns success on the second address.
var testFn rpcSendFn = func(_ rpc.Options, method string, addrs []net.Addr, getArgs func(addr net.Addr) interface{}, getReply func() interface{}, _ *rpc.Context) ([]interface{}, error) {
if method == "Node.Scan" {
// reply from first address failed
_ = getReply()
// reply from second address succeed
reply := getReply()
reply.(*proto.ScanResponse).Rows = append([]proto.KeyValue{}, proto.KeyValue{Key: proto.Key("b"), Value: proto.Value{}})
return []interface{}{reply}, nil
}
return nil, util.Errorf("Not expected method %v", method)
}
ctx := &DistSenderContext{
rpcSend: testFn,
rangeDescriptorDB: mockRangeDescriptorDB(func(_ proto.Key, _ lookupOptions) ([]proto.RangeDescriptor, error) {
return []proto.RangeDescriptor{descriptor}, nil
}),
}
ds := NewDistSender(ctx, g)
call := proto.ScanCall(proto.Key("a"), proto.Key("d"), 1)
sr := call.Reply.(*proto.ScanResponse)
ds.Send(context.Background(), call)
if err := sr.GoError(); err != nil {
t.Fatal(err)
}
if l := len(sr.Rows); l != 1 {
t.Fatalf("expected 1 row; got %d", l)
}
}
示例9: TestPrefixConfigSort
// TestPrefixConfigSort verifies sorting of keys.
func TestPrefixConfigSort(t *testing.T) {
defer leaktest.AfterTest(t)
keys := []proto.Key{
proto.KeyMax,
proto.Key("c"),
proto.Key("a"),
proto.Key("b"),
proto.Key("aa"),
proto.Key("\xfe"),
proto.KeyMin,
}
expKeys := []proto.Key{
proto.KeyMin,
proto.Key("a"),
proto.Key("aa"),
proto.Key("b"),
proto.Key("c"),
proto.Key("\xfe"),
proto.KeyMax,
}
pcc := &PrefixConfigMap{}
for _, key := range keys {
pcc.Configs = append(pcc.Configs, PrefixConfig{Prefix: key})
}
sort.Sort(pcc)
for i, pc := range pcc.Configs {
if bytes.Compare(pc.Prefix, expKeys[i]) != 0 {
t.Errorf("order for index %d incorrect; expected %q, got %q", i, expKeys[i], pc.Prefix)
}
}
}
示例10: TestTxnCoordIdempotentCleanup
// TestTxnCoordIdempotentCleanup verifies that cleanupTxn is idempotent.
func TestTxnCoordIdempotentCleanup(t *testing.T) {
defer leaktest.AfterTest(t)
s := createTestDB(t)
defer s.Stop()
txn := newTxn(s.Clock, proto.Key("a"))
pReply := &proto.PutResponse{}
key := proto.Key("a")
call := proto.Call{
Args: createPutRequest(key, []byte("value"), txn),
Reply: pReply,
}
if err := sendCall(s.Sender, call); err != nil {
t.Fatal(err)
}
if pReply.Error != nil {
t.Fatal(pReply.GoError())
}
s.Sender.cleanupTxn(nil, *txn) // first call
etReply := &proto.EndTransactionResponse{}
if err := sendCall(s.Sender, proto.Call{
Args: &proto.EndTransactionRequest{
RequestHeader: proto.RequestHeader{
Key: txn.Key,
Timestamp: txn.Timestamp,
Txn: txn,
},
Commit: true,
},
Reply: etReply,
}); /* second call */ err != nil {
t.Fatal(err)
}
}
示例11: TestTxnCoordSenderMultipleTxns
// TestTxnCoordSenderMultipleTxns verifies correct operation with
// multiple outstanding transactions.
func TestTxnCoordSenderMultipleTxns(t *testing.T) {
defer leaktest.AfterTest(t)
s := createTestDB(t)
defer s.Stop()
defer teardownHeartbeats(s.Sender)
txn1 := newTxn(s.Clock, proto.Key("a"))
txn2 := newTxn(s.Clock, proto.Key("b"))
call := proto.Call{
Args: createPutRequest(proto.Key("a"), []byte("value"), txn1),
Reply: &proto.PutResponse{}}
if err := sendCall(s.Sender, call); err != nil {
t.Fatal(err)
}
call = proto.Call{
Args: createPutRequest(proto.Key("b"), []byte("value"), txn2),
Reply: &proto.PutResponse{}}
if err := sendCall(s.Sender, call); err != nil {
t.Fatal(err)
}
if len(s.Sender.txns) != 2 {
t.Errorf("expected length of transactions map to be 2; got %d", len(s.Sender.txns))
}
}
示例12: ValidateRangeMetaKey
// ValidateRangeMetaKey validates that the given key is a valid Range Metadata
// key.
func ValidateRangeMetaKey(key proto.Key) error {
// KeyMin is a valid key.
if key.Equal(proto.KeyMin) {
return nil
}
// Key must be at least as long as Meta1Prefix.
if len(key) < len(Meta1Prefix) {
return NewInvalidRangeMetaKeyError("too short", key)
}
prefix, body := proto.Key(key[:len(Meta1Prefix)]), proto.Key(key[len(Meta1Prefix):])
if prefix.Equal(Meta2Prefix) {
if body.Less(proto.KeyMax) {
return nil
}
return NewInvalidRangeMetaKeyError("body of meta2 range lookup is >= KeyMax", key)
}
if prefix.Equal(Meta1Prefix) {
if proto.KeyMax.Less(body) {
return NewInvalidRangeMetaKeyError("body of meta1 range lookup is > KeyMax", key)
}
return nil
}
return NewInvalidRangeMetaKeyError("not a meta key", key)
}
示例13: TestTxnCoordSenderEndTxn
// TestTxnCoordSenderEndTxn verifies that ending a transaction
// sends resolve write intent requests and removes the transaction
// from the txns map.
func TestTxnCoordSenderEndTxn(t *testing.T) {
defer leaktest.AfterTest(t)
s := createTestDB(t)
defer s.Stop()
txn := newTxn(s.Clock, proto.Key("a"))
pReply := &proto.PutResponse{}
key := proto.Key("a")
call := proto.Call{
Args: createPutRequest(key, []byte("value"), txn),
Reply: pReply,
}
if err := sendCall(s.Sender, call); err != nil {
t.Fatal(err)
}
if pReply.GoError() != nil {
t.Fatal(pReply.GoError())
}
etReply := &proto.EndTransactionResponse{}
s.Sender.Send(context.Background(), proto.Call{
Args: &proto.EndTransactionRequest{
RequestHeader: proto.RequestHeader{
Key: txn.Key,
Timestamp: txn.Timestamp,
Txn: txn,
},
Commit: true,
},
Reply: etReply,
})
if etReply.Error != nil {
t.Fatal(etReply.GoError())
}
verifyCleanup(key, s.Sender, s.Eng, t)
}
示例14: TestKVClientEmptyValues
// TestKVClientEmptyValues verifies that empty values are preserved
// for both empty []byte and integer=0. This used to fail when we
// allowed the protobufs to be gob-encoded using the default go rpc
// gob codec because gob treats pointer values and non-pointer values
// as equivalent and elides zero-valued defaults on decode.
func TestKVClientEmptyValues(t *testing.T) {
s := StartTestServer(t)
defer s.Stop()
kvClient := createTestClient(s.HTTPAddr)
kvClient.User = storage.UserRoot
kvClient.Call(proto.Put, proto.PutArgs(proto.Key("a"), []byte{}), &proto.PutResponse{})
kvClient.Call(proto.Put, &proto.PutRequest{
RequestHeader: proto.RequestHeader{
Key: proto.Key("b"),
},
Value: proto.Value{
Integer: gogoproto.Int64(0),
},
}, &proto.PutResponse{})
getResp := &proto.GetResponse{}
kvClient.Call(proto.Get, proto.GetArgs(proto.Key("a")), getResp)
if bytes := getResp.Value.Bytes; bytes == nil || len(bytes) != 0 {
t.Errorf("expected non-nil empty byte slice; got %q", bytes)
}
kvClient.Call(proto.Get, proto.GetArgs(proto.Key("b")), getResp)
if intVal := getResp.Value.Integer; intVal == nil || *intVal != 0 {
t.Errorf("expected non-nil 0-valued integer; got %p, %d", getResp.Value.Integer, getResp.Value.GetInteger())
}
}
示例15: TestRangeLookupOptionOnReverseScan
// TestRangeLookupOptionOnReverseScan verifies that a lookup triggered by a
// ReverseScan request has the `useReverseScan` option specified.
func TestRangeLookupOptionOnReverseScan(t *testing.T) {
defer leaktest.AfterTest(t)
g, s := makeTestGossip(t)
defer s()
var testFn rpcSendFn = func(_ rpc.Options, method string, addrs []net.Addr, getArgs func(addr net.Addr) gogoproto.Message, getReply func() gogoproto.Message, _ *rpc.Context) ([]gogoproto.Message, error) {
return []gogoproto.Message{getReply()}, nil
}
ctx := &DistSenderContext{
RPCSend: testFn,
RangeDescriptorDB: mockRangeDescriptorDB(func(k proto.Key, opts lookupOptions) ([]proto.RangeDescriptor, error) {
if len(k) > 0 && !opts.useReverseScan {
t.Fatalf("expected useReverseScan to be set")
}
return []proto.RangeDescriptor{testRangeDescriptor}, nil
}),
}
ds := NewDistSender(ctx, g)
rScan := &proto.ReverseScanRequest{
RequestHeader: proto.RequestHeader{Key: proto.Key("a"), EndKey: proto.Key("b")},
}
if _, err := batchutil.SendWrapped(ds, rScan); err != nil {
t.Fatal(err)
}
}