// FindRangeLease is similar to FindRangeLeaseHolder but returns a Lease proto // without verifying if the lease is still active. Instead, it returns a time- // stamp taken off the queried node's clock. func (tc *TestCluster) FindRangeLease( rangeDesc *roachpb.RangeDescriptor, hint *ReplicationTarget, ) (_ *roachpb.Lease, now hlc.Timestamp, _ error) { if hint != nil { var ok bool if _, ok = rangeDesc.GetReplicaDescriptor(hint.StoreID); !ok { return nil, hlc.ZeroTimestamp, errors.Errorf( "bad hint: %+v; store doesn't have a replica of the range", hint) } } else { hint = &ReplicationTarget{ NodeID: rangeDesc.Replicas[0].NodeID, StoreID: rangeDesc.Replicas[0].StoreID} } // Find the server indicated by the hint and send a LeaseInfoRequest through // it. var hintServer *server.TestServer for _, s := range tc.Servers { if s.GetNode().Descriptor.NodeID == hint.NodeID { hintServer = s break } } if hintServer == nil { return nil, hlc.ZeroTimestamp, errors.Errorf("bad hint: %+v; no such node", hint) } leaseReq := roachpb.LeaseInfoRequest{ Span: roachpb.Span{ Key: rangeDesc.StartKey.AsRawKey(), }, } leaseResp, pErr := client.SendWrappedWith( context.TODO(), hintServer.DB().GetSender(), roachpb.Header{ // INCONSISTENT read, since we want to make sure that the node used to // send this is the one that processes the command, for the hint to // matter. ReadConsistency: roachpb.INCONSISTENT, }, &leaseReq) if pErr != nil { return nil, hlc.ZeroTimestamp, pErr.GoError() } return leaseResp.(*roachpb.LeaseInfoResponse).Lease, hintServer.Clock().Now(), nil }
func TestLeaseInfoRequest(t *testing.T) { defer leaktest.AfterTest(t)() tc := testcluster.StartTestCluster(t, 3, base.TestClusterArgs{ ReplicationMode: base.ReplicationManual, }) defer tc.Stopper().Stop() kvDB0 := tc.Servers[0].DB() kvDB1 := tc.Servers[1].DB() key := []byte("a") rangeDesc := new(roachpb.RangeDescriptor) var err error *rangeDesc, err = tc.LookupRange(key) if err != nil { t.Fatal(err) } rangeDesc, err = tc.AddReplicas( rangeDesc.StartKey.AsRawKey(), tc.Target(1), tc.Target(2), ) if err != nil { t.Fatal(err) } if len(rangeDesc.Replicas) != 3 { t.Fatalf("expected 3 replicas, got %+v", rangeDesc.Replicas) } replicas := make([]roachpb.ReplicaDescriptor, 3) for i := 0; i < 3; i++ { var ok bool replicas[i], ok = rangeDesc.GetReplicaDescriptor(tc.Servers[i].GetFirstStoreID()) if !ok { t.Fatalf("expected to find replica in server %d", i) } } // Lease should start on Server 0, since nobody told it to move. leaseHolderReplica := LeaseInfo(t, kvDB0, *rangeDesc, roachpb.INCONSISTENT).Lease.Replica if leaseHolderReplica != replicas[0] { t.Fatalf("lease holder should be replica %+v, but is: %+v", replicas[0], leaseHolderReplica) } // Transfer the lease to Server 1 and check that LeaseInfoRequest gets the // right answer. err = tc.TransferRangeLease(rangeDesc, tc.Target(1)) if err != nil { t.Fatal(err) } // An inconsistent LeaseInfoReqeust on the old lease holder should give us the // right answer immediately, since the old holder has definitely applied the // transfer before TransferRangeLease returned. leaseHolderReplica = LeaseInfo(t, kvDB0, *rangeDesc, roachpb.INCONSISTENT).Lease.Replica if leaseHolderReplica != replicas[1] { t.Fatalf("lease holder should be replica %+v, but is: %+v", replicas[1], leaseHolderReplica) } // A read on the new lease holder does not necessarily succeed immediately, // since it might take a while for it to apply the transfer. util.SucceedsSoon(t, func() error { // We can't reliably do a CONSISTENT read here, even though we're reading // from the supposed lease holder, because this node might initially be // unaware of the new lease and so the request might bounce around for a // while (see #8816). leaseHolderReplica = LeaseInfo(t, kvDB1, *rangeDesc, roachpb.INCONSISTENT).Lease.Replica if leaseHolderReplica != replicas[1] { return errors.Errorf("lease holder should be replica %+v, but is: %+v", replicas[1], leaseHolderReplica) } return nil }) // Transfer the lease to Server 2 and check that LeaseInfoRequest gets the // right answer. err = tc.TransferRangeLease(rangeDesc, tc.Target(2)) if err != nil { t.Fatal(err) } leaseHolderReplica = LeaseInfo(t, kvDB1, *rangeDesc, roachpb.INCONSISTENT).Lease.Replica if leaseHolderReplica != replicas[2] { t.Fatalf("lease holder should be replica %+v, but is: %+v", replicas[2], leaseHolderReplica) } // TODO(andrei): test the side-effect of LeaseInfoRequest when there's no // active lease - the node getting the request is supposed to acquire the // lease. This requires a way to expire leases; the TestCluster probably needs // to use a mock clock. }