Пример #1
0
func InitLog(runmode, path string) {
	log.SetLevelByString("info")

	if runmode == "dev" {
		log.SetLevelByString("debug")
	}

	log.SetOutputByName(path)
}
Пример #2
0
func main() {
	flag.Parse()

	log.SetLevelByString(*logLevel)

	cfg := &server.Config{
		Addr:         *addr,
		ZKAddr:       *zk,
		RootPath:     *rootPath,
		SaveInterval: *interval,
	}

	oracle, err := server.NewTimestampOracle(cfg)
	if err != nil {
		log.Fatal(err)
	}

	go http.ListenAndServe(":5555", nil)

	sc := make(chan os.Signal, 1)
	signal.Notify(sc,
		syscall.SIGHUP,
		syscall.SIGINT,
		syscall.SIGTERM,
		syscall.SIGQUIT)

	go func() {
		sig := <-sc
		log.Infof("Got signal [%d] to exit.", sig)
		oracle.Close()
		os.Exit(0)
	}()

	oracle.Run()
}
Пример #3
0
func (s *testBinlogSuite) SetUpSuite(c *C) {
	logLevel := os.Getenv("log_level")
	log.SetLevelByString(logLevel)
	store, err := tikv.NewMockTikvStore()
	c.Assert(err, IsNil)
	s.store = store
	tidb.SetSchemaLease(0)
	s.unixFile = "/tmp/mock-binlog-pump"
	os.Remove(s.unixFile)
	l, err := net.Listen("unix", s.unixFile)
	c.Assert(err, IsNil)
	s.serv = grpc.NewServer()
	s.pump = new(mockBinlogPump)
	binlog.RegisterPumpServer(s.serv, s.pump)
	go s.serv.Serve(l)
	opt := grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
		return net.DialTimeout("unix", addr, timeout)
	})
	clientCon, err := grpc.Dial(s.unixFile, opt, grpc.WithInsecure())
	c.Assert(err, IsNil)
	c.Assert(clientCon, NotNil)
	binloginfo.PumpClient = binlog.NewPumpClient(clientCon)
	s.tk = testkit.NewTestKit(c, s.store)
	s.tk.MustExec("use test")
	domain := sessionctx.GetDomain(s.tk.Se.(context.Context))
	s.ddl = domain.DDL()
}
Пример #4
0
func (s *testStmtSuite) SetUpTest(c *C) {
	log.SetLevelByString("error")
	s.dbName = "teststmts"
	var err error
	s.testDB, err = sql.Open(tidb.DriverName, tidb.EngineGoLevelDBMemory+"/"+s.dbName+"/"+s.dbName)
	c.Assert(err, IsNil)
	// create db
	s.createDBSql = fmt.Sprintf("create database if not exists %s;", s.dbName)
	s.dropDBSql = fmt.Sprintf("drop database if exists %s;", s.dbName)
	s.useDBSql = fmt.Sprintf("use %s;", s.dbName)
	s.createTableSql = `
    CREATE TABLE test(id INT NOT NULL DEFAULT 1, name varchar(255), PRIMARY KEY(id));
    CREATE TABLE test1(id INT NOT NULL DEFAULT 2, name varchar(255), PRIMARY KEY(id), INDEX name(name));
    CREATE TABLE test2(id INT NOT NULL DEFAULT 3, name varchar(255), PRIMARY KEY(id));`

	s.selectSql = `SELECT * from test limit 2;`
	mustExec(c, s.testDB, s.createDBSql)
	mustExec(c, s.testDB, s.useDBSql)

	s.createSystemDBSQL = fmt.Sprintf("create database if not exists %s;", mysql.SystemDB)
	s.createUserTableSQL = tidb.CreateUserTable

	mustExec(c, s.testDB, s.createSystemDBSQL)
	mustExec(c, s.testDB, s.createUserTableSQL)
}
Пример #5
0
func (t *testPrivilegeSuite) SetUpTest(c *C) {
	log.SetLevelByString("error")
	t.dbName = "test"
	t.store = newStore(c, t.dbName)
	se := newSession(c, t.store, t.dbName)
	t.createDBSQL = fmt.Sprintf("create database if not exists %s;", t.dbName)
	t.createDB1SQL = fmt.Sprintf("create database if not exists %s1;", t.dbName)
	t.dropDBSQL = fmt.Sprintf("drop database if exists %s;", t.dbName)
	t.useDBSQL = fmt.Sprintf("use %s;", t.dbName)
	t.createTableSQL = `CREATE TABLE test(id INT NOT NULL DEFAULT 1, name varchar(255), PRIMARY KEY(id));`

	mustExec(c, se, t.createDBSQL)
	mustExec(c, se, t.createDB1SQL) // create database test1
	mustExec(c, se, t.useDBSQL)
	mustExec(c, se, t.createTableSQL)

	t.createSystemDBSQL = fmt.Sprintf("create database if not exists %s;", mysql.SystemDB)
	t.createUserTableSQL = tidb.CreateUserTable
	t.createDBPrivTableSQL = tidb.CreateDBPrivTable
	t.createTablePrivTableSQL = tidb.CreateTablePrivTable
	t.createColumnPrivTableSQL = tidb.CreateColumnPrivTable

	mustExec(c, se, t.createSystemDBSQL)
	mustExec(c, se, t.createUserTableSQL)
	mustExec(c, se, t.createDBPrivTableSQL)
	mustExec(c, se, t.createTablePrivTableSQL)
	mustExec(c, se, t.createColumnPrivTableSQL)
}
Пример #6
0
func main() {
	flag.Parse()

	if *lease < 0 {
		log.Fatalf("invalid lease seconds %d", *lease)
	}

	tidb.SetSchemaLease(time.Duration(*lease) * time.Second)

	log.SetLevelByString(*logLevel)
	store, err := tidb.NewStore(fmt.Sprintf("%s://%s", *store, *storePath))
	if err != nil {
		log.Fatal(err)
	}

	var driver relay.IDriver
	driver = relay.NewTiDBDriver(store)
	replayer, err := relay.NewReplayer(driver, *relayPath, *check)
	if err != nil {
		log.Fatal(err)
	}

	replayer.OnRecordRead = func(rec *relay.Record) {
		fmt.Printf("%s\n", rec)
	}

	err = replayer.Run()
	if err != nil {
		log.Fatal(errors.ErrorStack(err))
	}
}
Пример #7
0
// OpenDB opens the database in the given directory; if required, the database
// will be initialized.
func OpenDB(dir string) (err error) {
	log.SetLevelByString("error")

	dir = filepath.Join(dir, "tidb")
	_, err = os.Stat(dir)
	init := os.IsNotExist(err)

	name := "tidb"
	db, err = sqlx.Open("tidb", "goleveldb://"+dir+"/"+name)
	if err != nil {
		return fmt.Errorf("db open failed: %s", err)
	}
	if err := db.Ping(); err != nil {
		return fmt.Errorf("db ping failed: %s", err)
	}

	if init {
		// b, err := ioutil.ReadFile(filepath.Join("data", "schema.sql"))
		// if err != nil {
		// return fmt.Errorf("read schema file failed: %s", err)
		// }
		// if _, err = db.Exec(string(b)); err != nil {
		if _, err = db.Exec(schemasql); err != nil {
			return fmt.Errorf("exec schema failed: %s", err)
		}
		if err = insertCards(); err != nil {
			return fmt.Errorf("insert cards failed: %s", err)
		}
	}

	return nil
}
Пример #8
0
func main() {
	tidb.RegisterLocalStore("boltdb", boltdb.Driver{})
	tidb.RegisterStore("tikv", tikv.Driver{})

	metric.RunMetric(3 * time.Second)
	printer.PrintTiDBInfo()
	runtime.GOMAXPROCS(runtime.NumCPU())

	flag.Parse()

	if *lease < 0 {
		log.Fatalf("invalid lease seconds %d", *lease)
	}

	tidb.SetSchemaLease(time.Duration(*lease) * time.Second)

	cfg := &server.Config{
		Addr:       fmt.Sprintf(":%s", *port),
		LogLevel:   *logLevel,
		StatusAddr: fmt.Sprintf(":%s", *statusPort),
		Socket:     *socket,
	}

	log.SetLevelByString(cfg.LogLevel)
	store, err := tidb.NewStore(fmt.Sprintf("%s://%s", *store, *storePath))
	if err != nil {
		log.Fatal(errors.ErrorStack(err))
	}
	// Create a session to load information schema.
	se, err := tidb.CreateSession(store)
	if err != nil {
		log.Fatal(errors.ErrorStack(err))
	}
	se.Close()

	var driver server.IDriver
	driver = server.NewTiDBDriver(store)
	var svr *server.Server
	svr, err = server.NewServer(cfg, driver)
	if err != nil {
		log.Fatal(errors.ErrorStack(err))
	}

	sc := make(chan os.Signal, 1)
	signal.Notify(sc,
		syscall.SIGHUP,
		syscall.SIGINT,
		syscall.SIGTERM,
		syscall.SIGQUIT)

	go func() {
		sig := <-sc
		log.Infof("Got signal [%d] to exit.", sig)
		svr.Close()
		os.Exit(0)
	}()

	log.Error(svr.Run())
}
Пример #9
0
func (s *testTableRsetSuite) SetUpSuite(c *C) {
	log.SetLevelByString("error")
	s.dbName = "rset_test"
	s.tableName = "rset_table"

	s.createTableSql = fmt.Sprintf("create table if not exists %s(id int);", s.tableName)
	s.querySql = fmt.Sprintf("select * from %s;", s.tableName)
}
Пример #10
0
func main() {
	log.SetLevelByString(*logLevel)
	createTable(forceDrop)
	{
		timing("insert test data", func() {
			insertTestData(*concurrent)
		})
	}
}
Пример #11
0
func (s *testKVSuite) SetUpSuite(c *C) {
	store, err := tidb.NewStore(fmt.Sprintf("%s://%s", *testStore, *testStorePath))
	c.Assert(err, IsNil)
	s.s = store

	cacheS, _ := tidb.NewStore(fmt.Sprintf("%s://%s", *testStore, *testStorePath))
	c.Assert(cacheS, Equals, store)
	log.SetLevelByString("warn")
}
Пример #12
0
func main() {
	log.SetLevelByString(*logLevel)
	timing("create table", func() {
		createTable()
	})
	timing("insert test data", func() {
		insertTestData(*rows, *concurrent)
	})
}
Пример #13
0
func main() {
	flag.Parse()
	log.SetLevelByString("warn")
	go http.ListenAndServe(":9191", nil)

	value := make([]byte, *valueSize)
	t := time.Now()
	batchRawPut(value)

	fmt.Printf("\nelapse:%v, total %v\n", time.Since(t), *dataCnt)
}
Пример #14
0
func (s *testMainSuite) SetUpSuite(c *C) {
	s.dbName = "test_main_db"
	s.createDBSQL = fmt.Sprintf("create database if not exists %s;", s.dbName)
	s.dropDBSQL = fmt.Sprintf("drop database %s;", s.dbName)
	s.useDBSQL = fmt.Sprintf("use %s;", s.dbName)
	s.createTableSQL = `
    CREATE TABLE tbl_test(id INT NOT NULL DEFAULT 1, name varchar(255), PRIMARY KEY(id));
    CREATE TABLE tbl_test1(id INT NOT NULL DEFAULT 2, name varchar(255), PRIMARY KEY(id), INDEX name(name));
    CREATE TABLE tbl_test2(id INT NOT NULL DEFAULT 3, name varchar(255), PRIMARY KEY(id));`
	s.selectSQL = `SELECT * from tbl_test;`
	runtime.GOMAXPROCS(runtime.NumCPU())

	log.SetLevelByString("error")
}
Пример #15
0
func main() {
	metric.RunMetric(3 * time.Second)
	printer.PrintTiDBInfo()
	runtime.GOMAXPROCS(runtime.NumCPU())

	flag.Parse()

	if *lease <= 0 {
		log.Fatalf("invalid lease seconds %d", *lease)
	}

	tidb.SetSchemaLease(time.Duration(*lease) * time.Second)

	cfg := &server.Config{
		Addr:     fmt.Sprintf(":%s", *port),
		LogLevel: *logLevel,
	}

	log.SetLevelByString(cfg.LogLevel)
	store, err := tidb.NewStore(fmt.Sprintf("%s://%s", *store, *storePath))
	if err != nil {
		log.Fatal(err)
	}

	var driver server.IDriver
	driver = server.NewTiDBDriver(store)
	var svr *server.Server
	svr, err = server.NewServer(cfg, driver)
	if err != nil {
		log.Fatal(err)
	}

	sc := make(chan os.Signal, 1)
	signal.Notify(sc,
		syscall.SIGHUP,
		syscall.SIGINT,
		syscall.SIGTERM,
		syscall.SIGQUIT)

	go func() {
		sig := <-sc
		log.Infof("Got signal [%d] to exit.", sig)
		svr.Close()
		os.Exit(0)
	}()

	log.Error(svr.Run())
}
Пример #16
0
func (ts *TidbTestSuite) SetUpSuite(c *C) {
	log.SetLevelByString("error")
	store, err := tidb.NewStore("memory:///tmp/tidb")
	c.Assert(err, IsNil)
	ts.tidbdrv = NewTiDBDriver(store)
	cfg := &Config{
		Addr:       ":4001",
		LogLevel:   "debug",
		StatusAddr: ":10090",
	}
	server, err := NewServer(cfg, ts.tidbdrv)
	c.Assert(err, IsNil)
	ts.server = server
	go ts.server.Run()
	time.Sleep(time.Millisecond * 100)
}
Пример #17
0
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	log.SetLevelByString("debug")
	log.Errorf("begin create table")
	dropTable(tblName1)
	createTable(tblName1)
	dropTable(tblName2)
	createTable(tblName2)
	log.Errorf("create table finish")

	go func() {
		log.Error(http.ListenAndServe("localhost:8889", nil))
	}()

	batchInsert(5, 50000)
}
Пример #18
0
func main() {
	log.SetLevelByString(*logLevel)
	createTable(forceDrop)
	{
		timing("insert test data", func() {
			insertTestData(*rows, *concurrent)
		})
		if !*insertOnly {
			timing("select point data", func() {
				selectPointTestData(*rows, *N, *concurrent)
			})
			timing("select range data", func() {
				selectRangeTestData(*rows, *N, *concurrent)
			})
		}
	}
}
Пример #19
0
func (s *testSuite) SetUpSuite(c *C) {
	s.Parser = parser.New()
	flag.Lookup("mockTikv")
	useMockTikv := *mockTikv
	if useMockTikv {
		store, err := tikv.NewMockTikvStore()
		c.Assert(err, IsNil)
		s.store = store
		tidb.SetSchemaLease(0)
	} else {
		store, err := tidb.NewStore("memory://test/test")
		c.Assert(err, IsNil)
		s.store = store
	}
	logLevel := os.Getenv("log_level")
	log.SetLevelByString(logLevel)
	executor.BaseLookupTableTaskSize = 2
}
Пример #20
0
func init() {
	// set log settings
	log15.Root().SetHandler(log15.LvlFilterHandler(log15.LvlDebug, ext.FatalHandler(log15.StderrHandler)))

	// close tidb debug
	log.SetLevelByString("error")
	tidb.Debug = false

	// init global vars
	var (
		config   *Config = NewConfig()
		database *Db     = NewDB(config.Db.Driver, config.Db.DSN)
		server   *Web    = NewWeb(config.Http.Host, config.Http.Port, config.Http.Protocol)
	)
	Injector = pucore.NewInjector(config, database, server)
	Behavior = pucore.NewBehaviors()
	Modular = pucore.NewModular(Injector, Behavior)
}
Пример #21
0
func main() {
	printer.PrintTiDBInfo()
	runtime.GOMAXPROCS(runtime.NumCPU())

	flag.Parse()

	cfg := &server.Config{
		Addr:     fmt.Sprintf(":%s", *port),
		User:     "******",
		Password: "",
		LogLevel: *logLevel,
	}

	log.SetLevelByString(cfg.LogLevel)
	store, err := tidb.NewStore(fmt.Sprintf("%s://%s", *store, *storePath))
	if err != nil {
		log.Fatal(err)
	}
	server.CreateTiDBTestDatabase(store)

	var driver server.IDriver
	driver = server.NewTiDBDriver(store)
	var svr *server.Server
	svr, err = server.NewServer(cfg, driver)
	if err != nil {
		log.Fatal(err)
	}

	sc := make(chan os.Signal, 1)
	signal.Notify(sc,
		syscall.SIGHUP,
		syscall.SIGINT,
		syscall.SIGTERM,
		syscall.SIGQUIT)

	go func() {
		sig := <-sc
		log.Infof("Got signal [%d] to exit.", sig)
		svr.Close()
		os.Exit(0)
	}()

	log.Error(svr.Run())
}
Пример #22
0
func (ts *TidbTestSuite) SetUpSuite(c *C) {
	log.SetLevelByString("error")
	store, err := tidb.NewStore("memory:///tmp/tidb")
	c.Assert(err, IsNil)
	ts.tidbdrv = NewTiDBDriver(store)
	cfg := &Config{
		Addr:         ":4001",
		LogLevel:     "debug",
		StatusAddr:   ":10090",
		ReportStatus: true,
	}
	server, err := NewServer(cfg, ts.tidbdrv)
	c.Assert(err, IsNil)
	ts.server = server
	go ts.server.Run()
	waitUntilServerOnline()

	// Run this test here because parallel would affect the result of it.
	runTestStmtCount(c)
}
Пример #23
0
func main() {
	flag.Parse()

	if *lease < 0 {
		log.Fatalf("invalid lease seconds %d", *lease)
	}

	tidb.SetSchemaLease(time.Duration(*lease) * time.Second)

	log.SetLevelByString(*logLevel)
	store, err := tidb.NewStore(fmt.Sprintf("%s://%s", *store, *storePath))
	if err != nil {
		log.Fatal(err)
	}

	var driver relay.IDriver
	driver = relay.NewTiDBDriver(store)
	var svr *relay.Server
	svr, err = relay.NewServer(driver, fmt.Sprintf(":%s", *port), *relayPath)
	if err != nil {
		log.Fatal(err)
	}

	sc := make(chan os.Signal, 1)
	signal.Notify(sc,
		syscall.SIGHUP,
		syscall.SIGINT,
		syscall.SIGTERM,
		syscall.SIGQUIT)

	go func() {
		sig := <-sc
		log.Infof("Got signal [%d] to exit.", sig)
		svr.Close()
		time.Sleep(1 * time.Second)
		os.Exit(0)
	}()

	log.Error(svr.Run())
}
Пример #24
0
func (s *testBinlogSuite) SetUpSuite(c *C) {
	logLevel := os.Getenv("log_level")
	log.SetLevelByString(logLevel)
	store, err := tikv.NewMockTikvStore()
	c.Assert(err, IsNil)
	s.store = store
	tidb.SetSchemaLease(0)
	s.unixFile = "/tmp/mock-binlog-pump"
	l, err := net.Listen("unix", s.unixFile)
	c.Assert(err, IsNil)
	s.serv = grpc.NewServer()
	s.pump = new(mockBinlogPump)
	binlog.RegisterPumpServer(s.serv, s.pump)
	go s.serv.Serve(l)
	opt := grpc.WithDialer(func(addr string, timeout time.Duration) (net.Conn, error) {
		return net.DialTimeout("unix", addr, timeout)
	})
	clientCon, err := grpc.Dial(s.unixFile, opt, grpc.WithInsecure())
	c.Assert(err, IsNil)
	c.Assert(clientCon, NotNil)
	binloginfo.PumpClient = binlog.NewPumpClient(clientCon)
}
Пример #25
0
func (s *testRelaySuite) SetUpSuite(c *C) {
	log.SetLevelByString("error")

	store, err := tidb.NewStore("memory://test/test")
	c.Assert(err, IsNil)

	s.store = store
	s.path = "/tmp/test_mysqlrelay.log"

	server, err := NewServer(NewTiDBDriver(store), ":4001", s.path)
	c.Assert(err, IsNil)
	s.server = server

	go server.Run()

	time.Sleep(time.Millisecond * 100)

	dsn := "root@tcp(localhost:4001)/test?strict=true"
	db, err := sql.Open("mysql", dsn)
	c.Assert(err, IsNil)
	s.db = db
}
Пример #26
0
func main() {
	// Default log level is debug, set it to error to turn off debug log.
	log.SetLevelByString("error")

	// DriverName is 'tidb', dataSourceName is in the form of "<engine>://<dbPath>/<dbName>".
	// dbPath is the directory that stores the data files if you use a local storage engine.
	// dbName is the name of the database which you want to use.
	dbPath := "/Users/carolove/Project/tidb"
	dbName := "tidb"
	db, err := sql.Open("tidb", "goleveldb://"+dbPath+"/"+dbName)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	_, err = db.Exec("CREATE TABLE IF NOT EXISTS user (email CHAR(20), name CHAR(20), password CHAR(20))")
	if err != nil {
		log.Fatal(err)
	}

	_, err = db.Exec("INSERT INTO user VALUES (?,?,?)", "*****@*****.**", "chendan", "!honeywell1")
	if err != nil {
		log.Fatal(err)
	}

	row := db.QueryRow("SELECT email, name, password FROM user WHERE email = ?", "*****@*****.**")
	var email, name, password string
	err = row.Scan(&email, &name, &password)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("email is %s, name is %s, password is %s\n", email, name, password)

	_, err = db.Exec("DROP TABLE user")
	if err != nil {
		log.Fatal(err)
	}
}
Пример #27
0
func main() {
	flag.Parse()
	log.SetLevelByString("error")
	Init()

	value := make([]byte, *valueSize)
	t := time.Now()
	batchRW(value)
	resp, err := http.Get("http://localhost:9191/metrics")
	if err != nil {
		log.Fatal(err)
	}

	defer resp.Body.Close()
	text, err1 := ioutil.ReadAll(resp.Body)
	if err1 != nil {
		log.Fatal(err)
	}

	fmt.Println(string(text))

	fmt.Printf("\nelapse:%v, total %v\n", time.Since(t), *dataCnt)
}
Пример #28
0
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	log.SetLevelByString("debug")
	log.Errorf("begin create table")
	dropTable(tblName1)
	createTable(tblName1)
	dropTable(tblName2)
	createTable(tblName2)
	log.Errorf("create table finish")

	go func() {
		log.Error(http.ListenAndServe("localhost:8889", nil))
	}()

	wg := &sync.WaitGroup{}
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func() {
			batchInsert(1, 50000)
			wg.Done()
		}()
	}
	wg.Wait()
}
Пример #29
0
func init() {
	log.SetLevelByString("warn")
}
Пример #30
0
func init() {
	// disable unittest annoying log
	log.SetLevelByString("error")
}