func acquire(
s *server.TestServer, descID sqlbase.ID, version sqlbase.DescriptorVersion,
) (*csql.LeaseState, error) {
var lease *csql.LeaseState
err := s.DB().Txn(context.TODO(), func(txn *client.Txn) error {
var err error
lease, err = s.LeaseManager().(*csql.LeaseManager).Acquire(txn, descID, version)
return err
})
return lease, err
}
// 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
}
// splitRangeAtVal splits the range for a table with schema
// `CREATE TABLE test (k INT PRIMARY KEY)` at row with value pk (the row will be
// the first on the right of the split).
func splitRangeAtVal(
ts *server.TestServer, tableDesc *sqlbase.TableDescriptor, pk int,
) (roachpb.RangeDescriptor, roachpb.RangeDescriptor, error) {
if len(tableDesc.Indexes) != 0 {
return roachpb.RangeDescriptor{}, roachpb.RangeDescriptor{},
errors.Errorf("expected table with just a PK, got: %+v", tableDesc)
}
pik, err := sqlbase.MakePrimaryIndexKey(tableDesc, pk)
if err != nil {
return roachpb.RangeDescriptor{}, roachpb.RangeDescriptor{}, err
}
startKey := keys.MakeRowSentinelKey(pik)
leftRange, rightRange, err := ts.SplitRange(startKey)
if err != nil {
return roachpb.RangeDescriptor{}, roachpb.RangeDescriptor{},
errors.Wrapf(err, "failed to split at row: %d", pk)
}
return leftRange, rightRange, nil
}
func waitForConfigChange(t *testing.T, s *server.TestServer) config.SystemConfig {
var foundDesc sqlbase.Descriptor
var cfg config.SystemConfig
testutils.SucceedsSoon(t, func() error {
var ok bool
if cfg, ok = s.Gossip().GetSystemConfig(); ok {
if val := cfg.GetValue(configDescKey); val != nil {
if err := val.GetProto(&foundDesc); err != nil {
t.Fatal(err)
}
if id := foundDesc.GetDatabase().GetID(); id != configID {
return errors.Errorf("expected database id %d; got %d", configID, id)
}
return nil
}
}
return errors.Errorf("got nil system config")
})
return cfg
}
// forceNewConfig forces a system config update by writing a bogus descriptor with an
// incremented value inside. It then repeatedly fetches the gossip config until the
// just-written descriptor is found.
func forceNewConfig(t *testing.T, s *server.TestServer) config.SystemConfig {
configID++
configDesc := &sqlbase.Descriptor{
Union: &sqlbase.Descriptor_Database{
Database: &sqlbase.DatabaseDescriptor{
Name: "sentinel",
ID: configID,
Privileges: &sqlbase.PrivilegeDescriptor{},
},
},
}
// This needs to be done in a transaction with the system trigger set.
if err := s.DB().Txn(context.TODO(), func(txn *client.Txn) error {
txn.SetSystemConfigTrigger()
return txn.Put(configDescKey, configDesc)
}); err != nil {
t.Fatal(err)
}
return waitForConfigChange(t, s)
}
