// TestRangeLookupWithOpenTransaction verifies that range lookups are
// done in such a way (e.g. using inconsistent reads) that they
// proceed in the event that a write intent is extant at the meta
// index record being read.
func TestRangeLookupWithOpenTransaction(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
db := createTestClient(t, s.Stopper(), s.ServingAddr())
// Create an intent on the meta1 record by writing directly to the
// engine.
key := testutils.MakeKey(keys.Meta1Prefix, roachpb.KeyMax)
now := s.Clock().Now()
txn := roachpb.NewTransaction("txn", roachpb.Key("foobar"), 0, enginepb.SERIALIZABLE, now, 0)
if err := engine.MVCCPutProto(
context.Background(), s.(*server.TestServer).Engines()[0],
nil, key, now, txn, &roachpb.RangeDescriptor{}); err != nil {
t.Fatal(err)
}
// Now, with an intent pending, attempt (asynchronously) to read
// from an arbitrary key. This will cause the distributed sender to
// do a range lookup, which will encounter the intent. We're
// verifying here that the range lookup doesn't fail with a write
// intent error. If it did, it would go into a deadloop attempting
// to push the transaction, which in turn requires another range
// lookup, etc, ad nauseam.
if _, err := db.Get(context.TODO(), "a"); err != nil {
t.Fatal(err)
}
}
func TestBelowRaftProtos(t *testing.T) {
defer leaktest.AfterTest(t)()
// Enable the additional checks in TestMain. NB: running this test by itself
// will fail those extra checks - such failures are safe to ignore, so long
// as this test passes when run with the entire package's tests.
verifyBelowRaftProtos = true
slice := make([]byte, 1<<20)
for typ, fix := range belowRaftGoldenProtos {
if b, err := protoutil.Marshal(reflect.New(typ.Elem()).Interface().(proto.Message)); err != nil {
t.Fatal(err)
} else if err := verifyHash(b, fix.emptySum); err != nil {
t.Errorf("%s (empty): %s\n", typ, err)
}
randGen := rand.New(rand.NewSource(goldenSeed))
bytes := slice
numBytes := 0
for i := 0; i < itersPerProto; i++ {
if n, err := marshalTo(fix.populatedConstructor(randGen), bytes); err != nil {
t.Fatal(err)
} else {
bytes = bytes[n:]
numBytes += n
}
}
if err := verifyHash(slice[:numBytes], fix.populatedSum); err != nil {
t.Errorf("%s (populated): %s\n", typ, err)
}
}
}
func TestAcquireAndRelease(t *testing.T) {
defer leaktest.AfterTest(t)()
s, db := setup(t)
defer s.Stopper().Stop()
ctx := context.Background()
manual := hlc.NewManualClock(123)
clock := hlc.NewClock(manual.UnixNano, time.Nanosecond)
lm := client.NewLeaseManager(db, clock, client.LeaseManagerOptions{ClientID: clientID1})
l, err := lm.AcquireLease(ctx, leaseKey)
if err != nil {
t.Fatal(err)
}
if err := lm.ReleaseLease(ctx, l); err != nil {
t.Fatal(err)
}
if err := lm.ReleaseLease(ctx, l); !testutils.IsError(err, "unexpected value") {
t.Fatal(err)
}
l, err = lm.AcquireLease(ctx, leaseKey)
if err != nil {
t.Fatal(err)
}
if err := lm.ReleaseLease(ctx, l); err != nil {
t.Fatal(err)
}
}
func TestDropIndexInterleaved(t *testing.T) {
defer leaktest.AfterTest(t)()
const chunkSize = 200
params, _ := createTestServerParams()
params.Knobs = base.TestingKnobs{
SQLSchemaChanger: &sql.SchemaChangerTestingKnobs{
BackfillChunkSize: chunkSize,
},
}
s, sqlDB, kvDB := serverutils.StartServer(t, params)
defer s.Stopper().Stop()
numRows := 2*chunkSize + 1
createKVInterleavedTable(t, sqlDB, numRows)
tableDesc := sqlbase.GetTableDescriptor(kvDB, "t", "kv")
tablePrefix := roachpb.Key(keys.MakeTablePrefix(uint32(tableDesc.ID)))
checkKeyCount(t, kvDB, tablePrefix, 3*numRows)
if _, err := sqlDB.Exec(`DROP INDEX t.intlv@intlv_idx`); err != nil {
t.Fatal(err)
}
checkKeyCount(t, kvDB, tablePrefix, 2*numRows)
// Ensure that index is not active.
tableDesc = sqlbase.GetTableDescriptor(kvDB, "t", "intlv")
if _, _, err := tableDesc.FindIndexByName("intlv_idx"); err == nil {
t.Fatalf("table descriptor still contains index after index is dropped")
}
}
func TestDropTableInTxn(t *testing.T) {
defer leaktest.AfterTest(t)()
params, _ := createTestServerParams()
s, sqlDB, _ := serverutils.StartServer(t, params)
defer s.Stopper().Stop()
if _, err := sqlDB.Exec(`
CREATE DATABASE t;
CREATE TABLE t.kv (k CHAR PRIMARY KEY, v CHAR);
`); err != nil {
t.Fatal(err)
}
tx, err := sqlDB.Begin()
if err != nil {
t.Fatal(err)
}
if _, err := tx.Exec(`DROP TABLE t.kv`); err != nil {
t.Fatal(err)
}
// We might still be able to read/write in the table inside this transaction
// until the schema changer runs, but we shouldn't be able to ALTER it.
if _, err := tx.Exec(`ALTER TABLE t.kv ADD COLUMN w CHAR`); !testutils.IsError(err,
`table "kv" is being dropped`) {
t.Fatalf("different error than expected: %v", err)
}
// Can't commit after ALTER errored, so we ROLLBACK.
if err := tx.Rollback(); err != nil {
t.Fatal(err)
}
}
func TestRangeIterForward(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper := stop.NewStopper()
defer stopper.Stop()
g, clock := makeGossip(t, stopper)
ds := NewDistSender(DistSenderConfig{
Clock: clock,
RangeDescriptorDB: alphaRangeDescriptorDB,
}, g)
ctx := context.Background()
ri := NewRangeIterator(ds)
i := 0
span := roachpb.RSpan{
Key: roachpb.RKey(roachpb.KeyMin),
EndKey: roachpb.RKey([]byte("z")),
}
for ri.Seek(ctx, span.Key, Ascending); ri.Valid(); ri.Next(ctx) {
if !reflect.DeepEqual(alphaRangeDescriptors[i], ri.Desc()) {
t.Fatalf("%d: expected %v; got %v", i, alphaRangeDescriptors[i], ri.Desc())
}
i++
if !ri.NeedAnother(span) {
break
}
}
}
// The assertions in this test should also be caught by the integration tests on
// various drivers.
func TestParseTs(t *testing.T) {
defer leaktest.AfterTest(t)()
var parseTsTests = []struct {
strTimestamp string
expected time.Time
}{
// time.RFC3339Nano for github.com/lib/pq.
{"2006-07-08T00:00:00.000000123Z", time.Date(2006, 7, 8, 0, 0, 0, 123, time.FixedZone("UTC", 0))},
// The format accepted by pq.ParseTimestamp.
{"2001-02-03 04:05:06.123-07", time.Date(2001, time.February, 3, 4, 5, 6, 123000000, time.FixedZone("", -7*60*60))},
}
for i, test := range parseTsTests {
parsed, err := parseTs(test.strTimestamp)
if err != nil {
t.Errorf("%d could not parse [%s]: %v", i, test.strTimestamp, err)
continue
}
if !parsed.Equal(test.expected) {
t.Errorf("%d parsing [%s] got [%s] expected [%s]", i, test.strTimestamp, parsed, test.expected)
}
}
}
func TestStorePoolThrottle(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper, g, _, sp, _ := createTestStorePool(
TestTimeUntilStoreDead, false /* deterministic */, false /* defaultNodeLiveness */)
defer stopper.Stop()
sg := gossiputil.NewStoreGossiper(g)
sg.GossipStores(uniqueStore, t)
{
expected := sp.clock.Now().GoTime().Add(sp.declinedReservationsTimeout)
sp.throttle(throttleDeclined, 1)
sp.mu.Lock()
detail := sp.getStoreDetailLocked(1)
sp.mu.Unlock()
if !detail.throttledUntil.Equal(expected) {
t.Errorf("expected store to have been throttled to %v, found %v",
expected, detail.throttledUntil)
}
}
{
expected := sp.clock.Now().GoTime().Add(sp.failedReservationsTimeout)
sp.throttle(throttleFailed, 1)
sp.mu.Lock()
detail := sp.getStoreDetailLocked(1)
sp.mu.Unlock()
if !detail.throttledUntil.Equal(expected) {
t.Errorf("expected store to have been throttled to %v, found %v",
expected, detail.throttledUntil)
}
}
}
// TestStopperRunTaskPanic ensures that a panic handler can recover panicking
// tasks, and that no tasks are leaked when they panic.
func TestStopperRunTaskPanic(t *testing.T) {
defer leaktest.AfterTest(t)()
ch := make(chan interface{})
s := stop.NewStopper(stop.OnPanic(func(v interface{}) {
ch <- v
}))
// If RunTask were not panic-safe, Stop() would deadlock.
type testFn func()
explode := func() { panic(ch) }
for i, test := range []testFn{
func() {
_ = s.RunTask(explode)
},
func() {
_ = s.RunAsyncTask(context.Background(), func(_ context.Context) { explode() })
},
func() {
_ = s.RunLimitedAsyncTask(
context.Background(),
make(chan struct{}, 1),
true, /* wait */
func(_ context.Context) { explode() },
)
},
func() {
s.RunWorker(explode)
},
} {
go test()
recovered := <-ch
if recovered != ch {
t.Errorf("%d: unexpected recovered value: %+v", i, recovered)
}
}
}
func TestMixedDirections(t *testing.T) {
defer leaktest.AfterTest(t)()
s, db, cdb := serverutils.StartServer(t, base.TestServerArgs{
UseDatabase: "t",
})
defer s.Stopper().Stop()
rowRanges, tableDesc := setupRanges(db, s.(*server.TestServer), cdb, t)
lr := distsqlplan.NewSpanResolver(
s.DistSender(), s.Gossip(),
s.(*server.TestServer).GetNode().Descriptor,
distsqlplan.BinPackingLeaseHolderChoice)
ctx := context.Background()
it := lr.NewSpanResolverIterator()
spans := []spanWithDir{
orient(kv.Ascending, makeSpan(tableDesc, 11, 15))[0],
orient(kv.Descending, makeSpan(tableDesc, 1, 14))[0],
}
replicas, err := resolveSpans(ctx, it, spans...)
if err != nil {
t.Fatal(err)
}
expected := [][]rngInfo{
{onlyReplica(rowRanges[1])},
{onlyReplica(rowRanges[1]), onlyReplica(rowRanges[0])},
}
if err = expectResolved(replicas, expected...); err != nil {
t.Fatal(err)
}
}
// Test that table names are not treated as case sensitive by the name cache.
func TestTableNameNotCaseSensitive(t *testing.T) {
defer leaktest.AfterTest(t)()
s, db, kvDB := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
leaseManager := s.LeaseManager().(*LeaseManager)
if _, err := db.Exec(`
CREATE DATABASE t;
CREATE TABLE t.test (k CHAR PRIMARY KEY, v CHAR);
`); err != nil {
t.Fatal(err)
}
// Populate the name cache.
if _, err := db.Exec("SELECT * FROM t.test;"); err != nil {
t.Fatal(err)
}
tableDesc := sqlbase.GetTableDescriptor(kvDB, "t", "test")
// Check that we can get the table by a different name.
lease := leaseManager.tableNames.get(tableDesc.ParentID, "tEsT", s.Clock())
if lease == nil {
t.Fatalf("no name cache entry")
}
if err := leaseManager.Release(lease); err != nil {
t.Fatal(err)
}
}
func TestBadRequest(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
db := createTestClient(t, s.Stopper(), s.ServingAddr())
ctx := context.TODO()
// Write key "a".
if err := db.Put(ctx, "a", "value"); err != nil {
t.Fatal(err)
}
if _, err := db.Scan(ctx, "a", "a", 0); !testutils.IsError(err, "truncation resulted in empty batch") {
t.Fatalf("unexpected error on scan with startkey == endkey: %v", err)
}
if _, err := db.ReverseScan(ctx, "a", "a", 0); !testutils.IsError(err, "truncation resulted in empty batch") {
t.Fatalf("unexpected error on reverse scan with startkey == endkey: %v", err)
}
if err := db.DelRange(ctx, "x", "a"); !testutils.IsError(err, "truncation resulted in empty batch") {
t.Fatalf("unexpected error on deletion on [x, a): %v", err)
}
if err := db.DelRange(ctx, "", "z"); !testutils.IsError(err, "must be greater than LocalMax") {
t.Fatalf("unexpected error on deletion on [KeyMin, z): %v", err)
}
}
// TestReverseScanWithSplitAndMerge verifies that ReverseScan gets the right results
// across multiple ranges while range splits and merges happen.
func TestReverseScanWithSplitAndMerge(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
db := initReverseScanTestEnv(s, t)
// Case 1: An encounter with a range split.
// Split the range ["b", "e") at "c".
if err := db.AdminSplit(context.TODO(), "c"); err != nil {
t.Fatal(err)
}
// The ReverseScan will run into a stale descriptor.
if rows, err := db.ReverseScan(context.TODO(), "a", "d", 0); err != nil {
t.Fatalf("unexpected error on ReverseScan: %s", err)
} else if l := len(rows); l != 3 {
t.Errorf("expected 3 rows; got %d", l)
}
// Case 2: encounter with range merge .
// Merge the range ["e", "g") and ["g", "\xff\xff") .
if err := db.AdminMerge(context.TODO(), "e"); err != nil {
t.Fatal(err)
}
if rows, err := db.ReverseScan(context.TODO(), "d", "g", 0); err != nil {
t.Fatalf("unexpected error on ReverseScan: %s", err)
} else if l := len(rows); l != 3 {
t.Errorf("expected 3 rows; got %d", l)
}
}
// TestMultiRangeReverseScan verifies that ReverseScan gets the right results
// across multiple ranges.
func TestMultiRangeReverseScan(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
db := initReverseScanTestEnv(s, t)
ctx := context.TODO()
// Case 1: Request.EndKey is in the middle of the range.
if rows, pErr := db.ReverseScan(ctx, "a", "d", 0); pErr != nil {
t.Fatalf("unexpected error on ReverseScan: %s", pErr)
} else if l := len(rows); l != 3 {
t.Errorf("expected 3 rows; got %d", l)
}
if rows, pErr := db.ReverseScan(ctx, "a", "d", 2); pErr != nil {
t.Fatalf("unexpected error on ReverseScan: %s", pErr)
} else if l := len(rows); l != 2 {
t.Errorf("expected 2 rows; got %d", l)
}
// Case 2: Request.EndKey is equal to the EndKey of the range.
if rows, pErr := db.ReverseScan(ctx, "d", "g", 0); pErr != nil {
t.Fatalf("unexpected error on ReverseScan: %s", pErr)
} else if l := len(rows); l != 3 {
t.Errorf("expected 3 rows; got %d", l)
}
}
// TestErrorDuringTransaction tests that the transaction abort count goes up when a query
// results in an error during a txn.
func TestAbortCountErrorDuringTransaction(t *testing.T) {
defer leaktest.AfterTest(t)()
params, _ := createTestServerParams()
s, sqlDB, _ := serverutils.StartServer(t, params)
defer s.Stopper().Stop()
txn, err := sqlDB.Begin()
if err != nil {
t.Fatal(err)
}
if _, err := txn.Query("SELECT * FROM i_do.not_exist"); err == nil {
t.Fatal("Expected an error but didn't get one")
}
if err := checkCounterEQ(s, sql.MetaTxnAbort, 1); err != nil {
t.Error(err)
}
if err := checkCounterEQ(s, sql.MetaTxnBegin, 1); err != nil {
t.Error(err)
}
if err := checkCounterEQ(s, sql.MetaSelect, 1); err != nil {
t.Error(err)
}
}
func TestStopperShouldQuiesce(t *testing.T) {
defer leaktest.AfterTest(t)()
s := stop.NewStopper()
running := make(chan struct{})
runningTask := make(chan struct{})
waiting := make(chan struct{})
cleanup := make(chan struct{})
// Run a worker. A call to stopper.Stop() will not close until all workers
// have completed, and this worker will complete when the "running" channel
// is closed.
s.RunWorker(func() {
<-running
})
// Run an asynchronous task. A stopper which has been Stop()ed will not
// close it's ShouldStop() channel until all tasks have completed. This task
// will complete when the "runningTask" channel is closed.
if err := s.RunAsyncTask(context.Background(), func(_ context.Context) {
<-runningTask
}); err != nil {
t.Fatal(err)
}
go func() {
// The ShouldQuiesce() channel should close as soon as the stopper is
// Stop()ed.
<-s.ShouldQuiesce()
// However, the ShouldStop() channel should still be blocked because the
// async task started above is still running, meaning we haven't quiesceed
// yet.
select {
case <-s.ShouldStop():
t.Fatal("expected ShouldStop() to block until quiesceing complete")
default:
// Expected.
}
// After completing the running task, the ShouldStop() channel should
// now close.
close(runningTask)
<-s.ShouldStop()
// However, the working running above prevents the call to Stop() from
// returning; it blocks until the runner's goroutine is finished. We
// use the "waiting" channel to detect this.
select {
case <-waiting:
t.Fatal("expected stopper to have blocked")
default:
// Expected.
}
// Finally, close the "running" channel, which should cause the original
// call to Stop() to return.
close(running)
<-waiting
close(cleanup)
}()
s.Stop()
close(waiting)
<-cleanup
}
func TestRangeIterSeekReverse(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper := stop.NewStopper()
defer stopper.Stop()
g, clock := makeGossip(t, stopper)
ds := NewDistSender(DistSenderConfig{
Clock: clock,
RangeDescriptorDB: alphaRangeDescriptorDB,
}, g)
ctx := context.Background()
ri := NewRangeIterator(ds)
i := len(alphaRangeDescriptors) - 1
for ri.Seek(ctx, roachpb.RKey([]byte{'z'}), Descending); ri.Valid(); {
if !reflect.DeepEqual(alphaRangeDescriptors[i], ri.Desc()) {
t.Fatalf("%d: expected %v; got %v", i, alphaRangeDescriptors[i], ri.Desc())
}
i -= 2
// Skip every other range.
nextByte := ri.Desc().StartKey[0] - 1
if nextByte <= byte('a') {
break
}
seekKey := roachpb.RKey([]byte{nextByte})
ri.Seek(ctx, seekKey, Descending)
if !ri.Key().Equal(seekKey) {
t.Errorf("expected iterator key %s; got %s", seekKey, ri.Key())
}
}
}
func TestStopper(t *testing.T) {
defer leaktest.AfterTest(t)()
s := stop.NewStopper()
running := make(chan struct{})
waiting := make(chan struct{})
cleanup := make(chan struct{})
s.RunWorker(func() {
<-running
})
go func() {
<-s.ShouldStop()
select {
case <-waiting:
t.Fatal("expected stopper to have blocked")
case <-time.After(1 * time.Millisecond):
// Expected.
}
close(running)
select {
case <-waiting:
// Success.
case <-time.After(100 * time.Millisecond):
t.Fatal("stopper should have finished waiting")
}
close(cleanup)
}()
s.Stop()
close(waiting)
<-cleanup
}
// Verify that when we enqueue the same range multiple times for the same
// reason, it is only processed once.
func TestSchedulerBuffering(t *testing.T) {
defer leaktest.AfterTest(t)()
p := newTestProcessor()
s := newRaftScheduler(log.AmbientContext{}, nil, p, 1)
stopper := stop.NewStopper()
defer stopper.Stop()
s.Start(stopper)
testCases := []struct {
state raftScheduleState
expected string
}{
{stateRaftReady, "ready=[1:1] request=[] tick=[]"},
{stateRaftRequest, "ready=[1:1] request=[1:1] tick=[]"},
{stateRaftTick, "ready=[1:1] request=[1:1] tick=[1:1]"},
{stateRaftReady | stateRaftRequest | stateRaftTick, "ready=[1:2] request=[1:2] tick=[1:2]"},
}
for _, c := range testCases {
s.signal(s.enqueueN(c.state, 1, 1, 1, 1, 1))
util.SucceedsSoon(t, func() error {
if s := p.String(); c.expected != s {
return errors.Errorf("expected %s, but got %s", c.expected, s)
}
return nil
})
}
}
func TestStopperIsStopped(t *testing.T) {
defer leaktest.AfterTest(t)()
s := stop.NewStopper()
bc := newBlockingCloser()
s.AddCloser(bc)
go s.Stop()
select {
case <-s.ShouldStop():
case <-time.After(100 * time.Millisecond):
t.Fatal("stopper should have finished waiting")
}
select {
case <-s.IsStopped():
t.Fatal("expected blocked closer to prevent stop")
case <-time.After(1 * time.Millisecond):
// Expected.
}
bc.Unblock()
select {
case <-s.IsStopped():
// Expected
case <-time.After(100 * time.Millisecond):
t.Fatal("stopper should have finished stopping")
}
}
func TestTimestampRoundtrip(t *testing.T) {
defer leaktest.AfterTest(t)()
ts := time.Date(2006, 7, 8, 0, 0, 0, 123000, time.FixedZone("UTC", 0))
parse := func(encoded []byte) time.Time {
decoded, err := parseTs(string(encoded))
if err != nil {
t.Fatal(err)
}
return decoded.UTC()
}
if actual := parse(formatTs(ts, nil, nil)); !ts.Equal(actual) {
t.Fatalf("timestamp did not roundtrip got [%s] expected [%s]", actual, ts)
}
// Also check with a 0, positive, and negative offset.
CET := time.FixedZone("Europe/Paris", 0)
EST := time.FixedZone("America/New_York", 0)
for _, tz := range []*time.Location{time.UTC, CET, EST} {
if actual := parse(formatTs(ts, tz, nil)); !ts.Equal(actual) {
t.Fatalf("[%s]: timestamp did not roundtrip got [%s] expected [%s]", tz, actual, ts)
}
}
}
// TestNodeStatusResponse verifies that node status returns the expected
// results.
func TestNodeStatusResponse(t *testing.T) {
defer leaktest.AfterTest(t)()
s := startServer(t)
defer s.Stopper().Stop()
// First fetch all the node statuses.
wrapper := serverpb.NodesResponse{}
if err := getStatusJSONProto(s, "nodes", &wrapper); err != nil {
t.Fatal(err)
}
nodeStatuses := wrapper.Nodes
if len(nodeStatuses) != 1 {
t.Errorf("too many node statuses returned - expected:1 actual:%d", len(nodeStatuses))
}
if !reflect.DeepEqual(s.node.Descriptor, nodeStatuses[0].Desc) {
t.Errorf("node status descriptors are not equal\nexpected:%+v\nactual:%+v\n", s.node.Descriptor, nodeStatuses[0].Desc)
}
// Now fetch each one individually. Loop through the nodeStatuses to use the
// ids only.
for _, oldNodeStatus := range nodeStatuses {
nodeStatus := status.NodeStatus{}
if err := getStatusJSONProto(s, "nodes/"+oldNodeStatus.Desc.NodeID.String(), &nodeStatus); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(s.node.Descriptor, nodeStatus.Desc) {
t.Errorf("node status descriptors are not equal\nexpected:%+v\nactual:%+v\n", s.node.Descriptor, nodeStatus.Desc)
}
}
}
// TestDropTableInterleaved tests dropping a table that is interleaved within
// another table.
func TestDropTableInterleaved(t *testing.T) {
defer leaktest.AfterTest(t)()
params, _ := createTestServerParams()
s, sqlDB, kvDB := serverutils.StartServer(t, params)
defer s.Stopper().Stop()
numRows := 2*sql.TableTruncateChunkSize + 1
createKVInterleavedTable(t, sqlDB, numRows)
tableDesc := sqlbase.GetTableDescriptor(kvDB, "t", "kv")
tablePrefix := roachpb.Key(keys.MakeTablePrefix(uint32(tableDesc.ID)))
checkKeyCount(t, kvDB, tablePrefix, 3*numRows)
if _, err := sqlDB.Exec(`DROP TABLE t.intlv`); err != nil {
t.Fatal(err)
}
checkKeyCount(t, kvDB, tablePrefix, numRows)
// Test that deleted table cannot be used. This prevents regressions where
// name -> descriptor ID caches might make this statement erronously work.
if _, err := sqlDB.Exec(`SELECT * FROM t.intlv`); !testutils.IsError(
err, `table "t.intlv" does not exist`,
) {
t.Fatalf("different error than expected: %v", err)
}
}
// TestMetricsRecording verifies that Node statistics are periodically recorded
// as time series data.
func TestMetricsRecording(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, kvDB := serverutils.StartServer(t, base.TestServerArgs{
MetricsSampleInterval: 5 * time.Millisecond})
defer s.Stopper().Stop()
checkTimeSeriesKey := func(now int64, keyName string) error {
key := ts.MakeDataKey(keyName, "", ts.Resolution10s, now)
data := roachpb.InternalTimeSeriesData{}
return kvDB.GetProto(context.TODO(), key, &data)
}
// Verify that metrics for the current timestamp are recorded. This should
// be true very quickly.
util.SucceedsSoon(t, func() error {
now := s.Clock().PhysicalNow()
if err := checkTimeSeriesKey(now, "cr.store.livebytes.1"); err != nil {
return err
}
if err := checkTimeSeriesKey(now, "cr.node.sys.go.allocbytes.1"); err != nil {
return err
}
return nil
})
}
// TestStreamEncodeDecode generates random streams of EncDatums and passes them
// through a StreamEncoder and a StreamDecoder
func TestStreamEncodeDecode(t *testing.T) {
defer leaktest.AfterTest(t)()
rng, _ := randutil.NewPseudoRand()
for test := 0; test < 100; test++ {
rowLen := 1 + rng.Intn(20)
info := make([]DatumInfo, rowLen)
for i := range info {
info[i].Type = sqlbase.RandColumnType(rng)
info[i].Encoding = sqlbase.RandDatumEncoding(rng)
}
numRows := rng.Intn(100)
rows := make(sqlbase.EncDatumRows, numRows)
for i := range rows {
rows[i] = make(sqlbase.EncDatumRow, rowLen)
for j := range rows[i] {
rows[i][j] = sqlbase.DatumToEncDatum(info[j].Type,
sqlbase.RandDatum(rng, info[j].Type, true))
}
}
var trailerErr error
if rng.Intn(10) == 0 {
trailerErr = fmt.Errorf("test error %d", rng.Intn(100))
}
testRowStream(t, rng, rows, trailerErr)
}
}
func TestSpanStatsResponse(t *testing.T) {
defer leaktest.AfterTest(t)()
ts := startServer(t)
defer ts.Stopper().Stop()
httpClient, err := ts.GetHTTPClient()
if err != nil {
t.Fatal(err)
}
var response serverpb.SpanStatsResponse
request := serverpb.SpanStatsRequest{
NodeID: "1",
StartKey: []byte(roachpb.RKeyMin),
EndKey: []byte(roachpb.RKeyMax),
}
url := ts.AdminURL() + statusPrefix + "span"
if err := httputil.PostJSON(httpClient, url, &request, &response); err != nil {
t.Fatal(err)
}
if a, e := int(response.RangeCount), ExpectedInitialRangeCount(); a != e {
t.Errorf("expected %d ranges, found %d", e, a)
}
}
func TestRangeStatsInit(t *testing.T) {
defer leaktest.AfterTest(t)()
tc := testContext{}
stopper := stop.NewStopper()
defer stopper.Stop()
tc.Start(t, stopper)
ms := enginepb.MVCCStats{
LiveBytes: 1,
KeyBytes: 2,
ValBytes: 3,
IntentBytes: 4,
LiveCount: 5,
KeyCount: 6,
ValCount: 7,
IntentCount: 8,
IntentAge: 9,
GCBytesAge: 10,
LastUpdateNanos: 11,
}
if err := engine.MVCCSetRangeStats(context.Background(), tc.engine, 1, &ms); err != nil {
t.Fatal(err)
}
loadMS, err := engine.MVCCGetRangeStats(context.Background(), tc.engine, tc.repl.RangeID)
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(ms, loadMS) {
t.Errorf("mvcc stats mismatch %+v != %+v", ms, loadMS)
}
}
func TestSpanStatsGRPCResponse(t *testing.T) {
defer leaktest.AfterTest(t)()
ts := startServer(t)
defer ts.Stopper().Stop()
rpcStopper := stop.NewStopper()
defer rpcStopper.Stop()
rpcContext := rpc.NewContext(log.AmbientContext{}, ts.RPCContext().Config, ts.Clock(), rpcStopper)
request := serverpb.SpanStatsRequest{
NodeID: "1",
StartKey: []byte(roachpb.RKeyMin),
EndKey: []byte(roachpb.RKeyMax),
}
url := ts.ServingAddr()
conn, err := rpcContext.GRPCDial(url)
if err != nil {
t.Fatal(err)
}
client := serverpb.NewStatusClient(conn)
response, err := client.SpanStats(context.Background(), &request)
if err != nil {
t.Fatal(err)
}
if a, e := int(response.RangeCount), ExpectedInitialRangeCount(); a != e {
t.Errorf("expected %d ranges, found %d", e, a)
}
}
func TestReacquireLease(t *testing.T) {
defer leaktest.AfterTest(t)()
s, db := setup(t)
defer s.Stopper().Stop()
ctx := context.Background()
manual := hlc.NewManualClock(123)
clock := hlc.NewClock(manual.UnixNano, time.Nanosecond)
lm := client.NewLeaseManager(db, clock, client.LeaseManagerOptions{ClientID: clientID1})
l, err := lm.AcquireLease(ctx, leaseKey)
if err != nil {
t.Fatal(err)
}
// We allow re-acquiring the same lease as long as the client ID is
// the same to allow a client to reacquire its own leases rather than
// having to wait them out if it crashes and restarts.
l, err = lm.AcquireLease(ctx, leaseKey)
if err != nil {
t.Fatal(err)
}
if err := lm.ReleaseLease(ctx, l); err != nil {
t.Fatal(err)
}
}
// Tests a batch of bounded DelRange() requests.
func TestMultiRangeBoundedBatchDelRange(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
db := setupMultipleRanges(t, s, "a", "b", "c", "d", "e", "f", "g", "h")
// These are the expected results if there is no bound.
expResults := [][]string{
{"a1", "a2", "a3", "b1", "b2"},
{"c1", "c2", "d1"},
{"g1", "g2"},
}
maxExpCount := 0
for _, res := range expResults {
maxExpCount += len(res)
}
for bound := 1; bound <= 20; bound++ {
// Initialize all keys.
for _, key := range []string{"a1", "a2", "a3", "b1", "b2", "c1", "c2", "d1", "f1", "f2", "f3", "g1", "g2", "h1"} {
if err := db.Put(context.TODO(), key, "value"); err != nil {
t.Fatal(err)
}
}
b := &client.Batch{}
b.Header.MaxSpanRequestKeys = int64(bound)
spans := [][]string{{"a", "c"}, {"c", "f"}, {"g", "h"}}
for _, span := range spans {
b.DelRange(span[0], span[1], true)
}
if err := db.Run(context.TODO(), b); err != nil {
t.Fatal(err)
}
if len(expResults) != len(b.Results) {
t.Fatalf("bound: %d, only got %d results, wanted %d", bound, len(expResults), len(b.Results))
}
expCount := maxExpCount
if bound < maxExpCount {
expCount = bound
}
rem := expCount
for i, res := range b.Results {
// Verify that the KeyValue slice contains the given keys.
rem -= len(res.Keys)
for j, key := range res.Keys {
if expKey := expResults[i][j]; string(key) != expKey {
t.Errorf("%s: expected scan key %d, %d to be %q; got %q", errInfo(), i, j, expKey, key)
}
}
}
if rem != 0 {
t.Errorf("expected %d keys, got %d", bound, expCount-rem)
}
checkResumeSpanDelRangeResults(t, spans, b.Results, expResults, expCount)
}
}