func main() {
fmt.Print(banner)
log.SetLevelByString("info")
args, err := docopt.Parse(usage, nil, true, "codis proxy v0.1", true)
if err != nil {
log.Error(err)
}
// set config file
if args["-c"] != nil {
configFile = args["-c"].(string)
}
// set output log file
if args["-L"] != nil {
log.SetOutputByName(args["-L"].(string))
}
// set log level
if args["--log-level"] != nil {
log.SetLevelByString(args["--log-level"].(string))
}
// set cpu
if args["--cpu"] != nil {
cpus, err = strconv.Atoi(args["--cpu"].(string))
if err != nil {
log.Fatal(err)
}
}
// set addr
if args["--addr"] != nil {
addr = args["--addr"].(string)
}
// set http addr
if args["--http-addr"] != nil {
httpAddr = args["--http-addr"].(string)
}
wd, _ := os.Getwd()
log.Info("wd:", wd)
log.CrashLog(wd + ".dump")
router.CheckUlimit(1024)
runtime.GOMAXPROCS(cpus)
http.HandleFunc("/setloglevel", handleSetLogLevel)
go http.ListenAndServe(httpAddr, nil)
log.Info("running on ", addr)
conf, err := router.LoadConf(configFile)
if err != nil {
log.Fatal(err)
}
s := router.NewServer(addr, httpAddr, conf)
s.Run()
log.Warning("exit")
}
func main() {
log.SetLevelByString("info")
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
if createdDashboardNode {
releaseDashboardNode()
}
Fatal("ctrl-c or SIGTERM found, exit")
}()
args, err := docopt.Parse(usage, nil, true, "codis config v0.1", true)
if err != nil {
log.Error(err)
}
// set config file
var configFile string
var config *cfg.Cfg
if args["-c"] != nil {
configFile = args["-c"].(string)
config, err = utils.InitConfigFromFile(configFile)
if err != nil {
log.Warning("load config file error")
Fatal(err)
}
} else {
config, err = utils.InitConfig()
if err != nil {
log.Warning("load config file error")
Fatal(err)
}
}
// load global vars
globalEnv = env.LoadCodisEnv(config)
// set output log file
if args["-L"] != nil {
log.SetOutputByName(args["-L"].(string))
}
// set log level
if args["--log-level"] != nil {
log.SetLevelByString(args["--log-level"].(string))
}
cmd := args["<command>"].(string)
cmdArgs := args["<args>"].([]string)
go http.ListenAndServe(":10086", nil)
err = runCommand(cmd, cmdArgs)
if err != nil {
log.Fatal(errors.ErrorStack(err))
}
}
func LogVerbose(v string) {
switch v {
case "info":
log.SetLevelByString("info")
case "debug":
log.SetLevelByString("debug")
case "warning":
log.SetLevelByString("warning")
case "fatal":
log.SetLevelByString("fatal")
}
}
func (s *Server) resetSchemaInfo() error {
for _, c := range s.clients {
if len(c.txConns) > 0 {
return errors.Errorf("transaction exist")
}
}
cfg, err := config.ParseConfigFile(s.configFile)
if err != nil {
log.Error(err)
return err
}
s.cleanup()
s.autoSchamas = make(map[string]*tabletserver.SchemaInfo)
for _, n := range s.shards {
n.Close()
}
s.shards = nil
s.schemas = nil
log.Warningf("%#v", cfg)
log.SetLevelByString(cfg.LogLevel)
s.cfg = cfg
return s.loadSchemaInfo()
}
func handleSetLogLevel(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
level := r.Form.Get("level")
log.SetLevelByString(level)
log.Info("set log level to ", level)
w.Header().Set("Content-Type", "text/html")
w.Write([]byte("OK"))
}
func (pc *ProxyConfig) apply() {
log.SetLevelByString(pc.logLevel)
if pc.logFile != "" {
err := log.SetOutputByName(pc.logFile)
if err != nil {
log.Fatalf("ProxyConfig SetOutputByName %s failed %s ", pc.logFile, err.Error())
}
log.SetRotateByDay()
}
if pc.name == "" {
log.Fatal("ProxyConfig name must not empty")
}
if pc.port == 0 {
log.Fatal("ProxyConfig port must not 0")
}
if pc.cpu > runtime.NumCPU() {
log.Warningf("ProxyConfig cpu %d exceed %d, adjust to %d ", pc.cpu, runtime.NumCPU(), runtime.NumCPU())
pc.cpu = runtime.NumCPU()
}
if pc.maxConn > 10000 {
log.Warningf("ProxyConfig maxconn %d exceed 10000, adjust to 10000", pc.maxConn)
pc.maxConn = 10000
}
runtime.GOMAXPROCS(pc.cpu)
if pc.poolSize <= 0 || pc.poolSize > 30 {
log.Warning("ProxyConfig poolSize %d , adjust to 10 ", pc.poolSize)
pc.poolSize = 10
}
if pc.cpuFile != "" {
f, err := os.Create(pc.cpuFile)
if err != nil {
log.Fatal(err)
}
log.Warning("Archer start CPUProfile ", pc.cpuFile)
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if pc.memFile != "" {
f, err := os.Create(pc.memFile)
if err == nil {
log.Warning("Archer start HeapProfile ", pc.memFile)
pprof.WriteHeapProfile(f)
}
}
go func() {
log.Warning(http.ListenAndServe(":6061", nil))
}()
}
func main() {
flag.Parse()
log.SetLevelByString(*logLevel)
for {
groups, err := GetServerGroups()
if err != nil {
log.Error(errors.ErrorStack(err))
return
}
CheckAliveAndPromote(groups)
time.Sleep(3 * time.Second)
}
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
if len(*configFile) == 0 {
log.Error("must use a config file")
return
}
cfg, err := config.ParseConfigFile(*configFile)
if err != nil {
log.Error(err.Error())
return
}
log.SetLevelByString(cfg.LogLevel)
log.CrashLog("./cm-proxy.dump")
var svr *proxy.Server
svr, err = proxy.NewServer(*configFile)
if err != nil {
log.Error(err.Error())
return
}
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)
}()
go svr.Run()
http.HandleFunc("/api/reload", svr.HandleReload)
//todo: using configuration
http.ListenAndServe(":8888", nil)
}
func main() {
autoflags.Define(&config)
flag.Parse()
log.SetLevelByString(config.LogLevel)
// to avoid pprof being optimized by gofmt
log.Debug(pprof.Handler("profile"))
if len(config.LogFile) != 0 {
log.SetOutputByName(config.LogFile)
log.SetRotateByDay()
}
if config.LogEveryN <= 0 {
proxy.LogEveryN = 1
} else {
proxy.LogEveryN = config.LogEveryN
}
log.Infof("%#v", config)
sigChan := make(chan os.Signal)
signal.Notify(sigChan, os.Interrupt, os.Kill)
log.Infof("pid %d", os.Getpid())
if len(config.DebugAddr) != 0 {
http.HandleFunc("/setloglevel", handleSetLogLevel)
go func() {
log.Fatal(http.ListenAndServe(config.DebugAddr, nil))
}()
log.Infof("debug service listens on %s", config.DebugAddr)
}
// shuffle startup nodes
startupNodes := strings.Split(config.StartupNodes, ",")
indexes := rand.Perm(len(startupNodes))
for i, startupNode := range startupNodes {
startupNodes[i] = startupNodes[indexes[i]]
startupNodes[indexes[i]] = startupNode
}
connPool := proxy.NewConnPool(config.BackendIdleConnections, config.ConnectTimeout, config.ReadPrefer != proxy.READ_PREFER_MASTER)
dispatcher := proxy.NewDispatcher(startupNodes, config.SlotsReloadInterval, connPool, config.ReadPrefer)
if err := dispatcher.InitSlotTable(); err != nil {
log.Fatal(err)
}
proxy := proxy.NewProxy(config.Addr, dispatcher, connPool)
go proxy.Run()
sig := <-sigChan
log.Infof("terminated by %#v", sig)
proxy.Exit()
}
func main() {
log.SetLevelByString("info")
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
signal.Notify(c, syscall.SIGTERM)
go func() {
<-c
Fatal("ctrl-c or SIGTERM found, exit")
}()
// productName, _ = config.ReadString("product", "test")
args, err := docopt.Parse(usage, nil, true, "codis config v0.1", true)
if err != nil {
log.Error(err)
}
// set config file
if args["-c"] != nil {
configFile = args["-c"].(string)
config, err = utils.InitConfigFromFile(configFile)
if err != nil {
Fatal(err)
}
} else {
config, err = utils.InitConfig()
if err != nil {
Fatal(err)
}
}
// set output log file
if args["-L"] != nil {
log.SetOutputByName(args["-L"].(string))
}
// set log level
if args["--log-level"] != nil {
log.SetLevelByString(args["--log-level"].(string))
}
productName, _ = config.ReadString("product", "test")
zkAddr, _ = config.ReadString("zk", "localhost:2181")
zkConn, _ = zkhelper.ConnectToZk(zkAddr)
zkLock = utils.GetZkLock(zkConn, productName)
broker, _ = config.ReadString("broker", "ledisdb")
slot_num, _ = config.ReadInt("slot_num", 16)
log.Debugf("product: %s", productName)
log.Debugf("zk: %s", zkAddr)
log.Debugf("broker: %s", broker)
if err := registerConfigNode(); err != nil {
log.Fatal(errors.ErrorStack(err))
}
defer unRegisterConfigNode()
if err := removeOrphanLocks(); err != nil {
log.Fatal(errors.ErrorStack(err))
}
cmd := args["<command>"].(string)
cmdArgs := args["<args>"].([]string)
go http.ListenAndServe(":10086", nil)
err = runCommand(cmd, cmdArgs)
if err != nil {
log.Fatal(errors.ErrorStack(err))
}
}
func init() {
runtime.GOMAXPROCS(runtime.NumCPU())
log.SetLevelByString("info")
}
func handleSetLogLevel(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
level := r.Form.Get("level")
log.SetLevelByString(level)
log.Info("set log level to", level)
}
func NewProxyConfig(filename string) *ProxyConfig {
c, err := config.NewConfig("ini", filename)
if err != nil {
log.Fatal("read config file failed ", err)
}
loglevel := c.DefaultString("log::loglevel", "info")
log.SetLevelByString(loglevel)
logfile := c.DefaultString("log::logfile", "")
if logfile != "" {
err := log.SetOutputByName(logfile)
if err != nil {
log.Fatal("Set log Output failed ", err)
}
log.Info("Set log Output to file ", logfile)
log.SetRotateByDay()
}
cpus := c.DefaultInt("proxy::cpus", 4)
log.Info("set runtime GOMAXPROCS to ", cpus)
runtime.GOMAXPROCS(cpus)
pc := &ProxyConfig{
Id: c.DefaultString("product::id", ""),
Name: c.DefaultString("product::name", ""),
Port: c.DefaultString("proxy::port", ""),
SlaveOk: c.DefaultBool("proxy::slaveok", false),
IdleTime: c.DefaultInt64("proxy::idletime", 300),
MaxConn: c.DefaultInt64("proxy::maxconn", 60000),
Statsd: c.DefaultString("proxy::statsd", ""),
Zk: c.DefaultString("zk::zk", ""),
ZkPath: c.DefaultString("zk::zkpath", ""),
MulOpParallel: c.DefaultInt("proxy::mulparallel", 10),
PoolSizePerNode: c.DefaultInt("proxy::poolsizepernode", 30),
StatsdPrefix: c.DefaultString("proxy::prefix", "redis.proxy."),
FileName: filename,
}
pc.Config = c
nodes := c.DefaultString("proxy::nodes", "")
if nodes == "" {
log.Fatal("proxy nodes must not empty ")
}
pc.Nodes = strings.Split(nodes, ",")
if pc.Id == "" || pc.Name == "" || pc.Port == "" {
log.Fatal("id name or port must not empty")
}
if pc.PoolSizePerNode < MinPoolSizePerNode || pc.PoolSizePerNode > MaxPoolSizePerNode {
log.Info("Adjust PoolSizePerNode to 30")
pc.PoolSizePerNode = 30
}
if pc.MulOpParallel < MinMulOpParallel || pc.MulOpParallel > MaxMulOpParallel {
log.Info("Adjust MulOpParallel to 10")
pc.MulOpParallel = 10
}
if pc.MaxConn < MinMaxConn || pc.MaxConn > MaxMaxConn {
log.Info("Adjust MaxConn to 60000")
pc.MaxConn = 60000
}
if pc.IdleTime < MinIdleTime || pc.IdleTime > MaxIdleTime {
log.Info("Adjust MaxConn to 300")
pc.IdleTime = 300
}
fcpu := c.DefaultString("debug::cpufile", "")
if fcpu != "" {
f, err := os.Create(fcpu)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
fmem := c.DefaultString("debug::memfile", "")
if fmem != "" {
f, err := os.Create(fmem)
if err != nil {
log.Fatal(err)
}
pprof.WriteHeapProfile(f)
}
return pc
}
// setbyname will set name by value
// return old value of name
func (s *Session) proxyConfigSetByName(name string, value string) []byte {
var reply []byte
switch name {
case "loglevel":
v := strings.ToLower(value)
if v != "info" || v != "warning" || v != "debug" {
reply = []byte("-loglevel must be info warning or debug\r\n")
return reply
}
reply = s.proxyConfigGetByName(name)
log.SetLevelByString(v)
case "idletime":
v, err := strconv.Atoi(value)
if err != nil {
reply = []byte("-unavailable idletime\r\n")
return reply
}
if v < MinIdleTime || v > MaxIdleTime {
reply = []byte("-unavailable idletime, must between 10 ~ 300\r\n")
return reply
}
reply = s.proxyConfigGetByName("idletime")
s.Proxy.Conf.IdleTime = int64(v)
case "slaveok":
v, err := strconv.Atoi(value)
if err != nil {
reply = []byte("-unavailable slaveok,must 0 or 1\r\n")
return reply
}
if v != 0 || v != 1 {
reply = []byte("-unavailable slaveok,must 0 or 1\r\n")
return reply
}
reply = s.proxyConfigGetByName("slaveok")
if v == 1 {
s.Proxy.Conf.SlaveOk = true
} else {
s.Proxy.Conf.SlaveOk = false
}
case "mulparallel":
v, err := strconv.Atoi(value)
if err != nil {
reply = []byte("-unavailable mulparallel\r\n")
return reply
}
if v < MinMulOpParallel || v > MaxMulOpParallel {
reply = []byte("-unavailable mulparallel, must between 5 ~ 100\r\n")
return reply
}
reply = s.proxyConfigGetByName("mulparallel")
s.Proxy.Conf.MulOpParallel = v
case "statsd":
reply = s.proxyConfigGetByName("statsd")
s.Proxy.Conf.Statsd = value
case "maxconn":
v, err := strconv.Atoi(value)
if err != nil {
reply = []byte("-unavailable maxconn\r\n")
return reply
}
if v < MinMaxConn || v > MaxMaxConn {
reply = []byte("-unavailable maxconn, must between 100 ~ 60000\r\n")
return reply
}
reply = s.proxyConfigGetByName("maxconn")
s.Proxy.Conf.MaxConn = int64(v)
default:
reply = []byte("-wrong proxy config name\r\n")
}
return reply
}
