func (n *Node) checkMaster() {
db := n.Master
if db == nil {
golog.Error("Node", "checkMaster", "Master is no alive", 0)
return
}
if err := db.Ping(); err != nil {
golog.Error("Node", "checkMaster", "Ping", 0, "db.Addr", db.Addr(), "error", err.Error())
} else {
if atomic.LoadInt32(&(db.state)) == Down {
golog.Info("Node", "checkMaster", "Master up", 0, "db.Addr", db.Addr())
n.UpMaster(db.addr)
}
db.SetLastPing()
if atomic.LoadInt32(&(db.state)) != ManualDown {
atomic.StoreInt32(&(db.state), Up)
}
return
}
if int64(n.DownAfterNoAlive) > 0 && time.Now().Unix()-db.GetLastPing() > int64(n.DownAfterNoAlive/time.Second) {
golog.Info("Node", "checkMaster", "Master down", 0,
"db.Addr", db.Addr(),
"Master_down_time", int64(n.DownAfterNoAlive/time.Second))
n.DownMaster(db.addr, Down)
}
}
func (n *Node) checkSlave() {
n.RLock()
if n.Slave == nil {
n.RUnlock()
return
}
slaves := make([]*DB, len(n.Slave))
copy(slaves, n.Slave)
n.RUnlock()
for i := 0; i < len(slaves); i++ {
if err := slaves[i].Ping(); err != nil {
golog.Error("Node", "checkSlave", "Ping", 0, "db.Addr", slaves[i].Addr(), "error", err.Error())
} else {
if atomic.LoadInt32(&(slaves[i].state)) == Down {
golog.Info("Node", "checkSlave", "Slave up", 0, "db.Addr", slaves[i].Addr())
n.UpSlave(slaves[i].addr)
}
slaves[i].SetLastPing()
if atomic.LoadInt32(&(slaves[i].state)) != ManualDown {
atomic.StoreInt32(&(slaves[i].state), Up)
}
continue
}
if int64(n.DownAfterNoAlive) > 0 && time.Now().Unix()-slaves[i].GetLastPing() > int64(n.DownAfterNoAlive/time.Second) {
golog.Info("Node", "checkSlave", "Slave down", 0,
"db.Addr", slaves[i].Addr(),
"slave_down_time", int64(n.DownAfterNoAlive/time.Second))
//If can't ping slave after DownAfterNoAlive, set slave Down
n.DownSlave(slaves[i].addr, Down)
}
}
}
func (n *Node) checkSlave() {
n.Lock()
if n.Slave == nil {
n.Unlock()
return
}
slaves := make([]*DB, len(n.Slave))
copy(slaves, n.Slave)
n.Unlock()
for i := 0; i < len(slaves); i++ {
if atomic.LoadInt32(&(slaves[i].state)) == Down {
continue
}
if err := slaves[i].Ping(); err != nil {
golog.Error("Node", "checkSlave", "Ping", 0, "db.Addr", slaves[i].Addr(), "error", err.Error())
} else {
n.LastSlavePing = time.Now().Unix()
}
if int64(n.DownAfterNoAlive) > 0 && time.Now().Unix()-n.LastSlavePing > int64(n.DownAfterNoAlive) {
golog.Info("Node", "checkMaster", "Master down", 0,
"db.Addr", slaves[i].Addr(),
"slave_down_time", int64(n.DownAfterNoAlive/time.Second))
//If can't ping slave after DownAfterNoAlive, set slave Down
n.DownSlave(slaves[i].addr)
}
}
}
func (n *Node) checkMaster() {
db := n.Master
if db == nil {
golog.Error("Node", "checkMaster", "Master is no alive", 0)
return
}
if atomic.LoadInt32(&(db.state)) == Down {
return
}
if err := db.Ping(); err != nil {
golog.Error("Node", "checkMaster", "Ping", 0, "db.Addr", db.Addr(), "error", err.Error())
} else {
n.LastMasterPing = time.Now().Unix()
atomic.StoreInt32(&(db.state), Up)
return
}
if int64(n.DownAfterNoAlive) > 0 && time.Now().Unix()-n.LastMasterPing > int64(n.DownAfterNoAlive) {
golog.Info("Node", "checkMaster", "Master down", 0,
"db.Addr", db.Addr(),
"Master_down_time", int64(n.DownAfterNoAlive/time.Second))
n.DownMaster(db.addr)
}
}
func NewServer(cfg *config.Config) (*Server, error) {
s := new(Server)
s.cfg = cfg
s.counter = new(Counter)
s.addr = cfg.Addr
s.user = cfg.User
s.password = cfg.Password
atomic.StoreInt32(&s.statusIndex, 0)
s.status[s.statusIndex] = Online
atomic.StoreInt32(&s.logSqlIndex, 0)
s.logSql[s.logSqlIndex] = cfg.LogSql
atomic.StoreInt32(&s.slowLogTimeIndex, 0)
s.slowLogTime[s.slowLogTimeIndex] = cfg.SlowLogTime
if len(cfg.Charset) == 0 {
cfg.Charset = mysql.DEFAULT_CHARSET //utf8
}
cid, ok := mysql.CharsetIds[cfg.Charset]
if !ok {
return nil, errors.ErrInvalidCharset
}
//change the default charset
mysql.DEFAULT_CHARSET = cfg.Charset
mysql.DEFAULT_COLLATION_ID = cid
mysql.DEFAULT_COLLATION_NAME = mysql.Collations[cid]
if err := s.parseBlackListSqls(); err != nil {
return nil, err
}
if err := s.parseAllowIps(); err != nil {
return nil, err
}
if err := s.parseNodes(); err != nil {
return nil, err
}
if err := s.parseSchema(); err != nil {
return nil, err
}
var err error
netProto := "tcp"
s.listener, err = net.Listen(netProto, s.addr)
if err != nil {
return nil, err
}
golog.Info("server", "NewServer", "Server running", 0,
"netProto",
netProto,
"address",
s.addr)
return s, nil
}
func NewServer(cfg *config.Config) (*Server, error) {
s := new(Server)
s.cfg = cfg
s.counter = new(Counter)
s.addr = cfg.Addr
s.user = cfg.User
s.password = cfg.Password
if len(cfg.Charset) != 0 {
cid, ok := mysql.CharsetIds[cfg.Charset]
if !ok {
return nil, errors.ErrInvalidCharset
}
s.charset = cfg.Charset
s.collation = cid
} else {
s.charset = mysql.DEFAULT_CHARSET
s.collation = mysql.DEFAULT_COLLATION_ID
}
if err := s.parseBlackListSqls(); err != nil {
return nil, err
}
if err := s.parseAllowIps(); err != nil {
return nil, err
}
if err := s.parseNodes(); err != nil {
return nil, err
}
if err := s.parseSchema(); err != nil {
return nil, err
}
var err error
netProto := "tcp"
s.listener, err = net.Listen(netProto, s.addr)
if err != nil {
return nil, err
}
golog.Info("server", "NewServer", "Server running", 0,
"netProto",
netProto,
"address",
s.addr)
return s, nil
}
func NewApiServer(cfg *config.Config, srv *server.Server) (*ApiServer, error) {
s := new(ApiServer)
s.cfg = cfg
s.proxy = srv
s.webAddr = cfg.WebAddr
s.webUser = cfg.WebUser
s.webPassword = cfg.WebPassword
s.Echo = echo.New()
golog.Info("web", "NewApiServer", "Api Server running", 0,
"netProto",
"http",
"address",
s.webAddr)
return s, nil
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
if len(*configFile) == 0 {
fmt.Println("must use a config file")
return
}
cfg, err := config.ParseConfigFile(*configFile)
if err != nil {
fmt.Printf("parse config file error:%s", err.Error())
return
}
if *logLevel != "" {
setLogLevel(*logLevel)
} else {
setLogLevel(cfg.LogLevel)
}
var svr *server.Server
svr, err = server.NewServer(cfg)
if err != nil {
golog.Error("main", "main", err.Error(), 0)
return
}
sc := make(chan os.Signal, 1)
signal.Notify(sc,
syscall.SIGHUP,
syscall.SIGINT,
syscall.SIGTERM,
syscall.SIGQUIT)
go func() {
sig := <-sc
golog.Info("main", "main", "Got signal", 0, "signal", sig)
golog.GlobalLogger.Close()
svr.Close()
}()
svr.Run()
}
func NewServer(cfg *config.Config) (*Server, error) {
s := new(Server)
s.cfg = cfg
s.counter = new(Counter)
s.addr = cfg.Addr
s.user = cfg.User
s.password = cfg.Password
if err := s.parseBlackListSqls(); err != nil {
return nil, err
}
if err := s.parseAllowIps(); err != nil {
return nil, err
}
if err := s.parseNodes(); err != nil {
return nil, err
}
if err := s.parseSchema(); err != nil {
return nil, err
}
var err error
netProto := "tcp"
s.listener, err = net.Listen(netProto, s.addr)
if err != nil {
return nil, err
}
golog.Info("server", "NewServer", "Server running", 0,
"netProto",
netProto,
"address",
s.addr)
return s, nil
}
func (n *Node) checkSlave() {
if n.Slave == nil {
return
}
db := n.Slave
if err := db.Ping(); err != nil {
golog.Error("Node", "checkSlave", "Ping", 0, "db.Addr", db.Addr(), "error", err.Error())
} else {
n.LastSlavePing = time.Now().Unix()
}
if int64(n.DownAfterNoAlive) > 0 && time.Now().Unix()-n.LastSlavePing > int64(n.DownAfterNoAlive) {
golog.Info("Node", "checkMaster", "Master down", 0,
"db.Addr", db.Addr(),
"slave_down_time", int64(n.DownAfterNoAlive/time.Second))
n.DownSlave()
}
}
func NewServer(cfg *config.Config) (*Server, error) {
s := new(Server)
s.cfg = cfg
s.addr = cfg.Addr
s.user = cfg.User
s.password = cfg.Password
fmt.Println(s.cfg.Password)
if err := s.parseAllowIps(); err != nil {
return nil, err
}
if err := s.parseNodes(); err != nil {
return nil, err
}
if err := s.parseSchemas(); err != nil {
return nil, err
}
var err error
netProto := "tcp"
if strings.Contains(netProto, "/") {
netProto = "unix"
}
s.listener, err = net.Listen(netProto, s.addr)
if err != nil {
return nil, err
}
golog.Info("server", "NewServer", "Server running", 0,
"netProto",
netProto,
"address",
s.addr)
return s, nil
}
func (n *Node) checkMaster() {
n.Lock()
db := n.Master
n.Unlock()
if db == nil {
golog.Error("Node", "checkMaster", "Master is no alive", 0)
return
}
if err := db.Ping(); err != nil {
golog.Error("Node", "checkMaster", "Ping", 0, "db.Addr", db.Addr(), "error", err.Error())
} else {
n.LastMasterPing = time.Now().Unix()
return
}
if int64(n.DownAfterNoAlive) > 0 && time.Now().Unix()-n.LastMasterPing > int64(n.DownAfterNoAlive) {
golog.Info("Node", "checkMaster", "Master down", 0,
"db.Addr", db.Addr(),
"Master_down_time", int64(n.DownAfterNoAlive/time.Second))
n.DownMaster()
}
}
func main() {
fmt.Print(banner)
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
if len(*configFile) == 0 {
fmt.Println("must use a config file")
return
} else {
fmt.Printf("config file:%s\n", *configFile)
}
cfg, err := config.ParseConfigFile(*configFile)
if err != nil {
fmt.Printf("parse config file error:%v\n", err.Error())
return
}
//when the log file size greater than 1GB, kingshard will generate a new file
if len(cfg.LogPath) != 0 {
fmt.Printf("log dir path:%s\n", cfg.LogPath)
sysFilePath := path.Join(cfg.LogPath, sysLogName)
fmt.Printf("sys log file path:%s\n", sysFilePath)
sysFile, err := golog.NewRotatingFileHandler(sysFilePath, MaxLogSize, 1)
if err != nil {
fmt.Printf("new log file error:%v\n", err.Error())
return
}
golog.GlobalSysLogger = golog.New(sysFile, golog.Lfile|golog.Ltime|golog.Llevel)
sqlFilePath := path.Join(cfg.LogPath, sqlLogName)
sqlFile, err := golog.NewRotatingFileHandler(sqlFilePath, MaxLogSize, 1)
if err != nil {
fmt.Printf("new log file error:%v\n", err.Error())
return
}
fmt.Printf("sql log file path:%s\n", sqlFilePath)
golog.GlobalSqlLogger = golog.New(sqlFile, golog.Lfile|golog.Ltime|golog.Llevel)
}
if *logLevel != "" {
setLogLevel(*logLevel)
} else {
setLogLevel(cfg.LogLevel)
}
var svr *server.Server
svr, err = server.NewServer(cfg)
if err != nil {
golog.Error("main", "main", err.Error(), 0)
golog.GlobalSysLogger.Close()
golog.GlobalSqlLogger.Close()
return
}
sc := make(chan os.Signal, 1)
signal.Notify(sc,
syscall.SIGHUP,
syscall.SIGINT,
syscall.SIGTERM,
syscall.SIGQUIT)
go func() {
sig := <-sc
golog.Info("main", "main", "Got signal", 0, "signal", sig)
golog.GlobalSysLogger.Close()
golog.GlobalSqlLogger.Close()
svr.Close()
}()
svr.Run()
}
func main() {
fmt.Print(banner)
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
fmt.Printf("Git commit:%s\n", hack.Version)
fmt.Printf("Build time:%s\n", hack.Compile)
if *version {
return
}
if len(*configFile) == 0 {
fmt.Println("must use a config file")
return
}
cfg, err := config.ParseConfigFile(*configFile)
if err != nil {
fmt.Printf("parse config file error:%v\n", err.Error())
return
}
//when the log file size greater than 1GB, kingshard will generate a new file
if len(cfg.LogPath) != 0 {
sysFilePath := path.Join(cfg.LogPath, sysLogName)
sysFile, err := golog.NewRotatingFileHandler(sysFilePath, MaxLogSize, 1)
if err != nil {
fmt.Printf("new log file error:%v\n", err.Error())
return
}
golog.GlobalSysLogger = golog.New(sysFile, golog.Lfile|golog.Ltime|golog.Llevel)
sqlFilePath := path.Join(cfg.LogPath, sqlLogName)
sqlFile, err := golog.NewRotatingFileHandler(sqlFilePath, MaxLogSize, 1)
if err != nil {
fmt.Printf("new log file error:%v\n", err.Error())
return
}
golog.GlobalSqlLogger = golog.New(sqlFile, golog.Lfile|golog.Ltime|golog.Llevel)
}
if *logLevel != "" {
setLogLevel(*logLevel)
} else {
setLogLevel(cfg.LogLevel)
}
var svr *server.Server
svr, err = server.NewServer(cfg)
if err != nil {
golog.Error("main", "main", err.Error(), 0)
golog.GlobalSysLogger.Close()
golog.GlobalSqlLogger.Close()
return
}
sc := make(chan os.Signal, 1)
signal.Notify(sc,
syscall.SIGINT,
syscall.SIGTERM,
syscall.SIGQUIT,
syscall.SIGPIPE,
)
go func() {
for {
sig := <-sc
if sig == syscall.SIGINT || sig == syscall.SIGTERM || sig == syscall.SIGQUIT {
golog.Info("main", "main", "Got signal", 0, "signal", sig)
golog.GlobalSysLogger.Close()
golog.GlobalSqlLogger.Close()
svr.Close()
} else if sig == syscall.SIGPIPE {
golog.Info("main", "main", "Ignore broken pipe signal", 0)
}
}
}()
svr.Run()
}