You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
306 lines
7.6 KiB
306 lines
7.6 KiB
// Copyright 2016 PingCAP, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package tikv
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
"time"
|
|
|
|
. "github.com/pingcap/check"
|
|
"github.com/pingcap/errors"
|
|
"github.com/pingcap/failpoint"
|
|
pb "github.com/pingcap/kvproto/pkg/kvrpcpb"
|
|
"github.com/pingcap/kvproto/pkg/metapb"
|
|
"github.com/pingcap/kvproto/pkg/pdpb"
|
|
"github.com/pingcap/tidb/kv"
|
|
"github.com/pingcap/tidb/store/mockoracle"
|
|
"github.com/pingcap/tidb/store/tikv/tikvrpc"
|
|
pd "github.com/tikv/pd/client"
|
|
)
|
|
|
|
var errStopped = errors.New("stopped")
|
|
|
|
type testStoreSuite struct {
|
|
testStoreSuiteBase
|
|
}
|
|
|
|
type testStoreSerialSuite struct {
|
|
testStoreSuiteBase
|
|
}
|
|
|
|
type testStoreSuiteBase struct {
|
|
OneByOneSuite
|
|
store *tikvStore
|
|
}
|
|
|
|
var _ = Suite(&testStoreSuite{})
|
|
var _ = SerialSuites(&testStoreSerialSuite{})
|
|
|
|
func (s *testStoreSuiteBase) SetUpTest(c *C) {
|
|
s.store = NewTestStore(c).(*tikvStore)
|
|
}
|
|
|
|
func (s *testStoreSuiteBase) TearDownTest(c *C) {
|
|
c.Assert(s.store.Close(), IsNil)
|
|
}
|
|
|
|
func (s *testStoreSuite) TestOracle(c *C) {
|
|
o := &mockoracle.MockOracle{}
|
|
s.store.oracle = o
|
|
|
|
ctx := context.Background()
|
|
t1, err := s.store.getTimestampWithRetry(NewBackofferWithVars(ctx, 100, nil))
|
|
c.Assert(err, IsNil)
|
|
t2, err := s.store.getTimestampWithRetry(NewBackofferWithVars(ctx, 100, nil))
|
|
c.Assert(err, IsNil)
|
|
c.Assert(t1, Less, t2)
|
|
|
|
t1, err = o.GetLowResolutionTimestamp(ctx)
|
|
c.Assert(err, IsNil)
|
|
t2, err = o.GetLowResolutionTimestamp(ctx)
|
|
c.Assert(err, IsNil)
|
|
c.Assert(t1, Less, t2)
|
|
f := o.GetLowResolutionTimestampAsync(ctx)
|
|
c.Assert(f, NotNil)
|
|
_ = o.UntilExpired(0, 0)
|
|
|
|
// Check retry.
|
|
var wg sync.WaitGroup
|
|
wg.Add(2)
|
|
|
|
o.Disable()
|
|
go func() {
|
|
defer wg.Done()
|
|
time.Sleep(time.Millisecond * 100)
|
|
o.Enable()
|
|
}()
|
|
|
|
go func() {
|
|
defer wg.Done()
|
|
t3, err := s.store.getTimestampWithRetry(NewBackofferWithVars(ctx, tsoMaxBackoff, nil))
|
|
c.Assert(err, IsNil)
|
|
c.Assert(t2, Less, t3)
|
|
expired := s.store.oracle.IsExpired(t2, 50)
|
|
c.Assert(expired, IsTrue)
|
|
}()
|
|
|
|
wg.Wait()
|
|
}
|
|
|
|
type mockPDClient struct {
|
|
sync.RWMutex
|
|
client pd.Client
|
|
stop bool
|
|
}
|
|
|
|
func (c *mockPDClient) enable() {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
c.stop = false
|
|
}
|
|
|
|
func (c *mockPDClient) disable() {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
c.stop = true
|
|
}
|
|
|
|
func (c *mockPDClient) GetAllMembers(ctx context.Context) ([]*pdpb.Member, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (c *mockPDClient) GetClusterID(context.Context) uint64 {
|
|
return 1
|
|
}
|
|
|
|
func (c *mockPDClient) GetTS(ctx context.Context) (int64, int64, error) {
|
|
c.RLock()
|
|
defer c.RUnlock()
|
|
|
|
if c.stop {
|
|
return 0, 0, errors.Trace(errStopped)
|
|
}
|
|
return c.client.GetTS(ctx)
|
|
}
|
|
|
|
func (c *mockPDClient) GetTSAsync(ctx context.Context) pd.TSFuture {
|
|
return nil
|
|
}
|
|
|
|
func (c *mockPDClient) GetRegion(ctx context.Context, key []byte) (*pd.Region, error) {
|
|
c.RLock()
|
|
defer c.RUnlock()
|
|
|
|
if c.stop {
|
|
return nil, errors.Trace(errStopped)
|
|
}
|
|
return c.client.GetRegion(ctx, key)
|
|
}
|
|
|
|
func (c *mockPDClient) GetPrevRegion(ctx context.Context, key []byte) (*pd.Region, error) {
|
|
c.RLock()
|
|
defer c.RUnlock()
|
|
|
|
if c.stop {
|
|
return nil, errors.Trace(errStopped)
|
|
}
|
|
return c.client.GetPrevRegion(ctx, key)
|
|
}
|
|
|
|
func (c *mockPDClient) GetRegionByID(ctx context.Context, regionID uint64) (*pd.Region, error) {
|
|
c.RLock()
|
|
defer c.RUnlock()
|
|
|
|
if c.stop {
|
|
return nil, errors.Trace(errStopped)
|
|
}
|
|
return c.client.GetRegionByID(ctx, regionID)
|
|
}
|
|
|
|
func (c *mockPDClient) ScanRegions(ctx context.Context, startKey []byte, endKey []byte, limit int) ([]*metapb.Region, []*metapb.Peer, error) {
|
|
c.RLock()
|
|
defer c.RUnlock()
|
|
|
|
if c.stop {
|
|
return nil, nil, errors.Trace(errStopped)
|
|
}
|
|
return c.client.ScanRegions(ctx, startKey, endKey, limit)
|
|
}
|
|
|
|
func (c *mockPDClient) GetStore(ctx context.Context, storeID uint64) (*metapb.Store, error) {
|
|
c.RLock()
|
|
defer c.RUnlock()
|
|
|
|
if c.stop {
|
|
return nil, errors.Trace(errStopped)
|
|
}
|
|
return c.client.GetStore(ctx, storeID)
|
|
}
|
|
|
|
func (c *mockPDClient) GetAllStores(ctx context.Context, opts ...pd.GetStoreOption) ([]*metapb.Store, error) {
|
|
c.RLock()
|
|
defer c.Unlock()
|
|
|
|
if c.stop {
|
|
return nil, errors.Trace(errStopped)
|
|
}
|
|
return c.client.GetAllStores(ctx)
|
|
}
|
|
|
|
func (c *mockPDClient) UpdateGCSafePoint(ctx context.Context, safePoint uint64) (uint64, error) {
|
|
panic("unimplemented")
|
|
}
|
|
|
|
func (c *mockPDClient) UpdateServiceGCSafePoint(ctx context.Context, serviceID string, ttl int64, safePoint uint64) (uint64, error) {
|
|
panic("unimplemented")
|
|
}
|
|
|
|
func (c *mockPDClient) Close() {}
|
|
|
|
func (c *mockPDClient) ScatterRegion(ctx context.Context, regionID uint64) error {
|
|
return nil
|
|
}
|
|
|
|
func (c *mockPDClient) GetOperator(ctx context.Context, regionID uint64) (*pdpb.GetOperatorResponse, error) {
|
|
return &pdpb.GetOperatorResponse{Status: pdpb.OperatorStatus_SUCCESS}, nil
|
|
}
|
|
|
|
func (c *mockPDClient) GetLeaderAddr() string { return "mockpd" }
|
|
|
|
func (c *mockPDClient) ScatterRegionWithOption(ctx context.Context, regionID uint64, opts ...pd.ScatterRegionOption) error {
|
|
return nil
|
|
}
|
|
|
|
func (c *mockPDClient) GetMemberInfo(ctx context.Context) ([]*pdpb.Member, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
type checkRequestClient struct {
|
|
Client
|
|
priority pb.CommandPri
|
|
}
|
|
|
|
func (c *checkRequestClient) SendRequest(ctx context.Context, addr string, req *tikvrpc.Request, timeout time.Duration) (*tikvrpc.Response, error) {
|
|
resp, err := c.Client.SendRequest(ctx, addr, req, timeout)
|
|
if c.priority != req.Priority {
|
|
if resp.Resp != nil {
|
|
if getResp, ok := resp.Resp.(*pb.GetResponse); ok {
|
|
getResp.Error = &pb.KeyError{
|
|
Abort: "request check error",
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return resp, err
|
|
}
|
|
|
|
func (s *testStoreSuite) TestRequestPriority(c *C) {
|
|
client := &checkRequestClient{
|
|
Client: s.store.client,
|
|
}
|
|
s.store.client = client
|
|
|
|
// Cover 2PC commit.
|
|
txn, err := s.store.Begin()
|
|
c.Assert(err, IsNil)
|
|
client.priority = pb.CommandPri_High
|
|
txn.SetOption(kv.Priority, kv.PriorityHigh)
|
|
err = txn.Set([]byte("key"), []byte("value"))
|
|
c.Assert(err, IsNil)
|
|
err = txn.Commit(context.Background())
|
|
c.Assert(err, IsNil)
|
|
|
|
// Cover the basic Get request.
|
|
txn, err = s.store.Begin()
|
|
c.Assert(err, IsNil)
|
|
client.priority = pb.CommandPri_Low
|
|
txn.SetOption(kv.Priority, kv.PriorityLow)
|
|
_, err = txn.Get(context.TODO(), []byte("key"))
|
|
c.Assert(err, IsNil)
|
|
|
|
// A counter example.
|
|
client.priority = pb.CommandPri_Low
|
|
txn.SetOption(kv.Priority, kv.PriorityNormal)
|
|
_, err = txn.Get(context.TODO(), []byte("key"))
|
|
// err is translated to "try again later" by backoffer, so doesn't check error value here.
|
|
c.Assert(err, NotNil)
|
|
|
|
// Cover Seek request.
|
|
client.priority = pb.CommandPri_High
|
|
txn.SetOption(kv.Priority, kv.PriorityHigh)
|
|
iter, err := txn.Iter([]byte("key"), nil)
|
|
c.Assert(err, IsNil)
|
|
for iter.Valid() {
|
|
c.Assert(iter.Next(), IsNil)
|
|
}
|
|
iter.Close()
|
|
}
|
|
|
|
func (s *testStoreSerialSuite) TestOracleChangeByFailpoint(c *C) {
|
|
defer func() {
|
|
failpoint.Disable("github.com/pingcap/tidb/store/tikv/oracle/changeTSFromPD")
|
|
}()
|
|
c.Assert(failpoint.Enable("github.com/pingcap/tidb/store/tikv/oracle/changeTSFromPD",
|
|
"return(10000)"), IsNil)
|
|
o := &mockoracle.MockOracle{}
|
|
s.store.oracle = o
|
|
ctx := context.Background()
|
|
t1, err := s.store.getTimestampWithRetry(NewBackofferWithVars(ctx, 100, nil))
|
|
c.Assert(err, IsNil)
|
|
c.Assert(failpoint.Disable("github.com/pingcap/tidb/store/tikv/oracle/changeTSFromPD"), IsNil)
|
|
t2, err := s.store.getTimestampWithRetry(NewBackofferWithVars(ctx, 100, nil))
|
|
c.Assert(err, IsNil)
|
|
c.Assert(t1, Greater, t2)
|
|
}
|
|
|