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.
 
 

432 lines
15 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 session
import (
"context"
"fmt"
. "github.com/pingcap/check"
"github.com/pingcap/parser"
"github.com/pingcap/parser/auth"
"github.com/pingcap/tidb/domain"
"github.com/pingcap/tidb/kv"
"github.com/pingcap/tidb/meta"
"github.com/pingcap/tidb/sessionctx"
"github.com/pingcap/tidb/sessionctx/variable"
"github.com/pingcap/tidb/statistics"
"github.com/pingcap/tidb/util/testleak"
)
type testBootstrapSuite struct {
dbName string
dbNameBootstrap string
}
func (s *testBootstrapSuite) SetUpSuite(c *C) {
s.dbName = "test_bootstrap"
s.dbNameBootstrap = "test_main_db_bootstrap"
}
func (s *testBootstrapSuite) TestBootstrap(c *C) {
defer testleak.AfterTest(c)()
store, dom := newStoreWithBootstrap(c, s.dbName)
defer store.Close()
defer dom.Close()
se := newSession(c, store, s.dbName)
mustExecSQL(c, se, "USE mysql;")
r := mustExecSQL(c, se, `select * from user;`)
c.Assert(r, NotNil)
ctx := context.Background()
req := r.NewChunk()
err := r.Next(ctx, req)
c.Assert(err, IsNil)
c.Assert(req.NumRows() == 0, IsFalse)
datums := statistics.RowToDatums(req.GetRow(0), r.Fields())
match(c, datums, `%`, "root", []byte(""), "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "N", "Y", "Y", "Y", "Y")
c.Assert(se.Auth(&auth.UserIdentity{Username: "root", Hostname: "anyhost"}, []byte(""), []byte("")), IsTrue)
mustExecSQL(c, se, "USE test;")
// Check privilege tables.
mustExecSQL(c, se, "SELECT * from mysql.global_priv;")
mustExecSQL(c, se, "SELECT * from mysql.db;")
mustExecSQL(c, se, "SELECT * from mysql.tables_priv;")
mustExecSQL(c, se, "SELECT * from mysql.columns_priv;")
// Check privilege tables.
r = mustExecSQL(c, se, "SELECT COUNT(*) from mysql.global_variables;")
c.Assert(r, NotNil)
req = r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
c.Assert(req.GetRow(0).GetInt64(0), Equals, globalVarsCount())
// Check a storage operations are default autocommit after the second start.
mustExecSQL(c, se, "USE test;")
mustExecSQL(c, se, "drop table if exists t")
mustExecSQL(c, se, "create table t (id int)")
unsetStoreBootstrapped(store.UUID())
se.Close()
se, err = CreateSession4Test(store)
c.Assert(err, IsNil)
mustExecSQL(c, se, "USE test;")
mustExecSQL(c, se, "insert t values (?)", 3)
se, err = CreateSession4Test(store)
c.Assert(err, IsNil)
mustExecSQL(c, se, "USE test;")
r = mustExecSQL(c, se, "select * from t")
c.Assert(r, NotNil)
req = r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
datums = statistics.RowToDatums(req.GetRow(0), r.Fields())
match(c, datums, 3)
mustExecSQL(c, se, "drop table if exists t")
se.Close()
// Try to do bootstrap dml jobs on an already bootstraped TiDB system will not cause fatal.
// For https://github.com/pingcap/tidb/issues/1096
se, err = CreateSession4Test(store)
c.Assert(err, IsNil)
doDMLWorks(se)
}
func globalVarsCount() int64 {
var count int64
for _, v := range variable.SysVars {
if v.Scope != variable.ScopeSession {
count++
}
}
return count
}
// bootstrapWithOnlyDDLWork creates a new session on store but only do ddl works.
func (s *testBootstrapSuite) bootstrapWithOnlyDDLWork(store kv.Storage, c *C) {
ss := &session{
store: store,
parser: parser.New(),
sessionVars: variable.NewSessionVars(),
}
ss.txn.init()
ss.mu.values = make(map[fmt.Stringer]interface{})
ss.SetValue(sessionctx.Initing, true)
dom, err := domap.Get(store)
c.Assert(err, IsNil)
domain.BindDomain(ss, dom)
b, err := checkBootstrapped(ss)
c.Assert(b, IsFalse)
c.Assert(err, IsNil)
doDDLWorks(ss)
// Leave dml unfinished.
}
// testBootstrapWithError :
// When a session failed in bootstrap process (for example, the session is killed after doDDLWorks()).
// We should make sure that the following session could finish the bootstrap process.
func (s *testBootstrapSuite) TestBootstrapWithError(c *C) {
ctx := context.Background()
defer testleak.AfterTest(c)()
store := newStore(c, s.dbNameBootstrap)
defer store.Close()
s.bootstrapWithOnlyDDLWork(store, c)
dom, err := domap.Get(store)
c.Assert(err, IsNil)
domap.Delete(store)
dom.Close()
dom1, err := BootstrapSession(store)
c.Assert(err, IsNil)
defer dom1.Close()
se := newSession(c, store, s.dbNameBootstrap)
mustExecSQL(c, se, "USE mysql;")
r := mustExecSQL(c, se, `select * from user;`)
req := r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
c.Assert(req.NumRows() == 0, IsFalse)
row := req.GetRow(0)
datums := statistics.RowToDatums(row, r.Fields())
match(c, datums, `%`, "root", []byte(""), "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "N", "Y", "Y", "Y", "Y")
c.Assert(r.Close(), IsNil)
mustExecSQL(c, se, "USE test;")
// Check privilege tables.
mustExecSQL(c, se, "SELECT * from mysql.global_priv;")
mustExecSQL(c, se, "SELECT * from mysql.db;")
mustExecSQL(c, se, "SELECT * from mysql.tables_priv;")
mustExecSQL(c, se, "SELECT * from mysql.columns_priv;")
// Check role tables.
mustExecSQL(c, se, "SELECT * from mysql.role_edges;")
mustExecSQL(c, se, "SELECT * from mysql.default_roles;")
// Check global variables.
r = mustExecSQL(c, se, "SELECT COUNT(*) from mysql.global_variables;")
req = r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
v := req.GetRow(0)
c.Assert(v.GetInt64(0), Equals, globalVarsCount())
c.Assert(r.Close(), IsNil)
r = mustExecSQL(c, se, `SELECT VARIABLE_VALUE from mysql.TiDB where VARIABLE_NAME="bootstrapped";`)
req = r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
c.Assert(req.NumRows() == 0, IsFalse)
row = req.GetRow(0)
c.Assert(row.Len(), Equals, 1)
c.Assert(row.GetBytes(0), BytesEquals, []byte("True"))
c.Assert(r.Close(), IsNil)
}
// TestUpgrade tests upgrading
func (s *testBootstrapSuite) TestUpgrade(c *C) {
ctx := context.Background()
defer testleak.AfterTest(c)()
store, _ := newStoreWithBootstrap(c, s.dbName)
defer store.Close()
se := newSession(c, store, s.dbName)
mustExecSQL(c, se, "USE mysql;")
// bootstrap with currentBootstrapVersion
r := mustExecSQL(c, se, `SELECT VARIABLE_VALUE from mysql.TiDB where VARIABLE_NAME="tidb_server_version";`)
req := r.NewChunk()
err := r.Next(ctx, req)
row := req.GetRow(0)
c.Assert(err, IsNil)
c.Assert(req.NumRows() == 0, IsFalse)
c.Assert(row.Len(), Equals, 1)
c.Assert(row.GetBytes(0), BytesEquals, []byte(fmt.Sprintf("%d", currentBootstrapVersion)))
c.Assert(r.Close(), IsNil)
se1 := newSession(c, store, s.dbName)
ver, err := getBootstrapVersion(se1)
c.Assert(err, IsNil)
c.Assert(ver, Equals, int64(currentBootstrapVersion))
// Do something to downgrade the store.
// downgrade meta bootstrap version
txn, err := store.Begin()
c.Assert(err, IsNil)
m := meta.NewMeta(txn)
err = m.FinishBootstrap(int64(1))
c.Assert(err, IsNil)
err = txn.Commit(context.Background())
c.Assert(err, IsNil)
mustExecSQL(c, se1, `delete from mysql.TiDB where VARIABLE_NAME="tidb_server_version";`)
mustExecSQL(c, se1, fmt.Sprintf(`delete from mysql.global_variables where VARIABLE_NAME="%s";`,
variable.TiDBDistSQLScanConcurrency))
mustExecSQL(c, se1, `commit;`)
unsetStoreBootstrapped(store.UUID())
// Make sure the version is downgraded.
r = mustExecSQL(c, se1, `SELECT VARIABLE_VALUE from mysql.TiDB where VARIABLE_NAME="tidb_server_version";`)
req = r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
c.Assert(req.NumRows() == 0, IsTrue)
c.Assert(r.Close(), IsNil)
ver, err = getBootstrapVersion(se1)
c.Assert(err, IsNil)
c.Assert(ver, Equals, int64(0))
// Create a new session then upgrade() will run automatically.
dom1, err := BootstrapSession(store)
c.Assert(err, IsNil)
defer dom1.Close()
se2 := newSession(c, store, s.dbName)
r = mustExecSQL(c, se2, `SELECT VARIABLE_VALUE from mysql.TiDB where VARIABLE_NAME="tidb_server_version";`)
req = r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
c.Assert(req.NumRows() == 0, IsFalse)
row = req.GetRow(0)
c.Assert(row.Len(), Equals, 1)
c.Assert(row.GetBytes(0), BytesEquals, []byte(fmt.Sprintf("%d", currentBootstrapVersion)))
c.Assert(r.Close(), IsNil)
ver, err = getBootstrapVersion(se2)
c.Assert(err, IsNil)
c.Assert(ver, Equals, int64(currentBootstrapVersion))
// Verify that 'new_collation_enabled' is false.
r = mustExecSQL(c, se2, fmt.Sprintf(`SELECT VARIABLE_VALUE from mysql.TiDB where VARIABLE_NAME='%s';`, tidbNewCollationEnabled))
req = r.NewChunk()
err = r.Next(ctx, req)
c.Assert(err, IsNil)
c.Assert(req.NumRows(), Equals, 1)
c.Assert(req.GetRow(0).GetString(0), Equals, "False")
c.Assert(r.Close(), IsNil)
}
func (s *testBootstrapSuite) TestIssue20900_1(c *C) {
ctx := context.Background()
defer testleak.AfterTest(c)()
store, _ := newStoreWithBootstrap(c, s.dbName)
defer store.Close()
// test issue 20900, upgrade from v3.0 to v4.0.9+
seV3 := newSession(c, store, s.dbName)
txn, err := store.Begin()
c.Assert(err, IsNil)
m := meta.NewMeta(txn)
err = m.FinishBootstrap(int64(38))
c.Assert(err, IsNil)
err = txn.Commit(context.Background())
c.Assert(err, IsNil)
mustExecSQL(c, seV3, "update mysql.tidb set variable_value=38 where variable_name='tidb_server_version'")
mustExecSQL(c, seV3, "delete from mysql.tidb where variable_name='default_memory_quota_query'")
mustExecSQL(c, seV3, "commit")
unsetStoreBootstrapped(store.UUID())
ver, err := getBootstrapVersion(seV3)
c.Assert(err, IsNil)
c.Assert(ver, Equals, int64(38))
domV4, err := BootstrapSession(store)
c.Assert(err, IsNil)
defer domV4.Close()
seV4 := newSession(c, store, s.dbName)
ver, err = getBootstrapVersion(seV4)
c.Assert(err, IsNil)
c.Assert(ver, Equals, int64(currentBootstrapVersion))
r := mustExecSQL(c, seV4, "select @@tidb_mem_quota_query")
req := r.NewChunk()
r.Next(ctx, req)
c.Assert(req.GetRow(0).GetString(0), Equals, "34359738368")
r = mustExecSQL(c, seV4, "select variable_value from mysql.tidb where variable_name='default_memory_quota_query'")
req = r.NewChunk()
r.Next(ctx, req)
c.Assert(req.GetRow(0).GetString(0), Equals, "34359738368")
c.Assert(seV4.GetSessionVars().MemQuotaQuery, Equals, int64(34359738368))
mustExecSQL(c, seV4, `update mysql.tidb set variable_value = '123' where variable_name='default_memory_quota_query'`)
r = mustExecSQL(c, seV4, "select variable_value from mysql.tidb where variable_name='default_memory_quota_query'")
req = r.NewChunk()
r.Next(ctx, req)
c.Assert(req.GetRow(0).GetString(0), Equals, "123")
se2 := newSession(c, store, s.dbName)
r = mustExecSQL(c, se2, "select @@tidb_mem_quota_query")
req = r.NewChunk()
r.Next(ctx, req)
c.Assert(req.GetRow(0).GetString(0), Equals, "34359738368")
c.Assert(se2.GetSessionVars().MemQuotaQuery, Equals, int64(34359738368))
}
func (s *testBootstrapSuite) TestIssue20900_2(c *C) {
ctx := context.Background()
defer testleak.AfterTest(c)()
store, _ := newStoreWithBootstrap(c, s.dbName)
defer store.Close()
// test issue 20900, upgrade from v4.0.8 to v4.0.9+
seV3 := newSession(c, store, s.dbName)
txn, err := store.Begin()
c.Assert(err, IsNil)
m := meta.NewMeta(txn)
err = m.FinishBootstrap(int64(48))
c.Assert(err, IsNil)
err = txn.Commit(context.Background())
c.Assert(err, IsNil)
mustExecSQL(c, seV3, "update mysql.tidb set variable_value=48 where variable_name='tidb_server_version'")
mustExecSQL(c, seV3, "delete from mysql.tidb where variable_name='default_memory_quota_query'")
mustExecSQL(c, seV3, "commit")
unsetStoreBootstrapped(store.UUID())
ver, err := getBootstrapVersion(seV3)
c.Assert(err, IsNil)
c.Assert(ver, Equals, int64(48))
domV4, err := BootstrapSession(store)
c.Assert(err, IsNil)
defer domV4.Close()
seV4 := newSession(c, store, s.dbName)
ver, err = getBootstrapVersion(seV4)
c.Assert(err, IsNil)
c.Assert(ver, Equals, int64(currentBootstrapVersion))
r := mustExecSQL(c, seV4, "select @@tidb_mem_quota_query")
req := r.NewChunk()
r.Next(ctx, req)
c.Assert(req.GetRow(0).GetString(0), Equals, "1073741824")
c.Assert(seV4.GetSessionVars().MemQuotaQuery, Equals, int64(1073741824))
r = mustExecSQL(c, seV4, "select variable_value from mysql.tidb where variable_name='default_memory_quota_query'")
req = r.NewChunk()
r.Next(ctx, req)
c.Assert(req.NumRows(), Equals, 0)
}
func (s *testBootstrapSuite) TestANSISQLMode(c *C) {
defer testleak.AfterTest(c)()
store, dom := newStoreWithBootstrap(c, s.dbName)
defer store.Close()
se := newSession(c, store, s.dbName)
mustExecSQL(c, se, "USE mysql;")
mustExecSQL(c, se, `set @@global.sql_mode="NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION,ANSI"`)
mustExecSQL(c, se, `delete from mysql.TiDB where VARIABLE_NAME="tidb_server_version";`)
unsetStoreBootstrapped(store.UUID())
se.Close()
// Do some clean up, BootstrapSession will not create a new domain otherwise.
dom.Close()
domap.Delete(store)
// Set ANSI sql_mode and bootstrap again, to cover a bugfix.
// Once we have a SQL like that:
// select variable_value from mysql.tidb where variable_name = "system_tz"
// it fails to execute in the ANSI sql_mode, and makes TiDB cluster fail to bootstrap.
dom1, err := BootstrapSession(store)
c.Assert(err, IsNil)
defer dom1.Close()
se = newSession(c, store, s.dbName)
mustExecSQL(c, se, "select @@global.sql_mode")
se.Close()
}
func (s *testBootstrapSuite) TestOldPasswordUpgrade(c *C) {
pwd := "abc"
oldpwd := fmt.Sprintf("%X", auth.Sha1Hash([]byte(pwd)))
newpwd, err := oldPasswordUpgrade(oldpwd)
c.Assert(err, IsNil)
c.Assert(newpwd, Equals, "*0D3CED9BEC10A777AEC23CCC353A8C08A633045E")
}
func (s *testBootstrapSuite) TestBootstrapInitExpensiveQueryHandle(c *C) {
defer testleak.AfterTest(c)()
store := newStore(c, s.dbName)
defer store.Close()
se, err := createSession(store)
c.Assert(err, IsNil)
dom := domain.GetDomain(se)
c.Assert(dom, NotNil)
defer dom.Close()
dom.InitExpensiveQueryHandle()
c.Assert(dom.ExpensiveQueryHandle(), NotNil)
}
func (s *testBootstrapSuite) TestStmtSummary(c *C) {
defer testleak.AfterTest(c)()
ctx := context.Background()
store, dom := newStoreWithBootstrap(c, s.dbName)
defer store.Close()
defer dom.Close()
se := newSession(c, store, s.dbName)
mustExecSQL(c, se, `update mysql.global_variables set variable_value='' where variable_name='tidb_enable_stmt_summary'`)
writeStmtSummaryVars(se)
r := mustExecSQL(c, se, "select variable_value from mysql.global_variables where variable_name='tidb_enable_stmt_summary'")
req := r.NewChunk()
c.Assert(r.Next(ctx, req), IsNil)
row := req.GetRow(0)
c.Assert(row.GetBytes(0), BytesEquals, []byte("1"))
c.Assert(r.Close(), IsNil)
}