func unmarshalFile(name string, val interface{}) { if name != "" { data, err := ioutil.ReadFile(name) if err != nil { relog.Fatal("could not read %v: %v", val, err) } if err = json.Unmarshal(data, val); err != nil { relog.Fatal("could not read %s: %v", val, err) } } data, _ := json.MarshalIndent(val, "", " ") relog.Info("config: %s\n", data) }
func Init(logPrefix string) { if logPrefix != "" { logPrefix += " " } logPrefix += fmt.Sprintf("[%v]", os.Getpid()) f, err := logfile.Open(*logfileName, *logFrequency, *logMaxSize, *logMaxFiles) if err != nil { panic(fmt.Sprintf("unable to open logfile %s: %v", *logfileName, err)) } logger := relog.New(f, logPrefix+" ", log.Ldate|log.Lmicroseconds|log.Lshortfile, relog.LogNameToLogLevel(*logLevel)) relog.SetLogger(logger) if *gomaxprocs != 0 { runtime.GOMAXPROCS(*gomaxprocs) relog.Info("set GOMAXPROCS = %v", *gomaxprocs) } fdLimit := &syscall.Rlimit{*maxOpenFds, *maxOpenFds} if err := syscall.Setrlimit(syscall.RLIMIT_NOFILE, fdLimit); err != nil { relog.Fatal("can't Setrlimit %#v: err %v", *fdLimit, err) } else { relog.Info("set max-open-fds = %v", *maxOpenFds) } }
func main() { flag.Usage = Usage flag.Parse() if *showVersion { fmt.Printf("agent_leveldb version is %.2f\n", agent_server.Version) return } agent_server.Init("agent_leveldb") if *configFile != "" { agent_server.Parse_config(*configFile) } if *laddr == "" { fmt.Fprintln(os.Stderr, "require a listen address") flag.Usage() os.Exit(1) } if *cpuprofile != "" { f, err := os.Create(*cpuprofile) if err != nil { relog.Fatal("%s", err) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } signal_init() agent_server.Run_server(*laddr) }
func serve() { AddShutdownCallback(ShutdownCallback(func() error { relog.Error("testserver GracefulShutdown callback"); return nil })) err := ListenAndServe("/tmp/test-sock") if err != nil { relog.Fatal("listen err:%v", err) } relog.Info("test server finished") }
// this is a callback to bind and startup an http server. // usually it is called like: // umgmt.AddStartupCallback(func () { umgmt.StartHttpServer(addr) }) func StartHttpServer(addr string) { httpListener, httpErr := net.Listen("tcp", addr) go func() { if httpErr == nil { httpListener = newHttpListener(httpListener) AddListener(httpListener) httpErr = http.Serve(httpListener, nil) httpListener.Close() } if httpErr != nil { switch e := httpErr.(type) { case *net.OpError: switch e.Err { case syscall.EADDRINUSE: relog.Fatal("StartHttpServer failed: %v", e) } case error: // NOTE(msolomon) even though these are Errno objects, the constants // are typed as os.Error. switch e { // FIXME(msolomon) this needs to be migrated into the system library // because this needs to be properly handled in the accept loop. case syscall.EMFILE, syscall.ENFILE: relog.Error("non-fatal error serving HTTP: %s", e.Error()) case syscall.EINVAL: // nothing - listener was probably closed default: relog.Error("http.ListenAndServe: " + httpErr.Error()) } default: relog.Error("http.ListenAndServe: " + httpErr.Error()) } } }() }
func main() { memProfileRate := flag.Int("mem-profile-rate", 512*1024, "profile every n bytes allocated") maxOpenFds := flag.Uint64("max-open-fds", 32768, "max open file descriptors") configFile := flag.String("config", "", "config file name") dbConfigFile := flag.String("dbconfig", "", "db config file name") lameDuckPeriod := flag.Float64("lame-duck-period", DefaultLameDuckPeriod, "how long to give in-flight transactions to finish") rebindDelay := flag.Float64("rebind-delay", DefaultRebindDelay, "artificial delay before rebinding a hijacked listener") logfileName := flag.String("logfile", "/dev/stderr", "base log file name") logFrequency := flag.Int64("logfile.frequency", 0, "rotation frequency in seconds") logMaxSize := flag.Int64("logfile.maxsize", 0, "max file size in bytes") logMaxFiles := flag.Int64("logfile.maxfiles", 0, "max number of log files") queryLog := flag.String("querylog", "", "for testing: log all queries to this file") flag.Parse() exportBinaryVersion() runtime.MemProfileRate = *memProfileRate f, err := logfile.Open(*logfileName, *logFrequency, *logMaxSize, *logMaxFiles) if err != nil { panic(fmt.Sprintf("unable to open logfile %s", *logfileName)) } logger := relog.New(f, "vtocc ", log.Ldate|log.Lmicroseconds|log.Lshortfile, relog.DEBUG) relog.SetLogger(logger) if *queryLog != "" { if f, err = os.OpenFile(*queryLog, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0644); err == nil { ts.QueryLogger = relog.New(f, "", log.Ldate|log.Lmicroseconds, relog.DEBUG) } } unmarshalFile(*configFile, &config) unmarshalFile(*dbConfigFile, &dbconfig) // work-around for jsonism if v, ok := dbconfig["port"].(float64); ok { dbconfig["port"] = int(v) } fdLimit := &syscall.Rlimit{*maxOpenFds, *maxOpenFds} if err = syscall.Setrlimit(RLIMIT_NOFILE, fdLimit); err != nil { relog.Fatal("can't Setrlimit %#v: err %v", *fdLimit, err) } else { relog.Info("set max-open-fds = %v", *maxOpenFds) } snitch.RegisterCommand("reload_schema", "Rescan the schema for new tables", ReloadHandler) snitch.Register() qm := &OccManager{config, dbconfig} rpc.Register(qm) ts.StartQueryService( config.PoolSize, config.TransactionCap, config.TransactionTimeout, config.MaxResultSize, config.QueryCacheSize, config.SchemaReloadTime, config.QueryTimeout, config.IdleTimeout, ) ts.AllowQueries(ts.GenericConnectionCreator(dbconfig), nil) rpc.HandleHTTP() jsonrpc.ServeHTTP() jsonrpc.ServeRPC() bsonrpc.ServeHTTP() bsonrpc.ServeRPC() relog.Info("started vtocc %v", config.Port) // we delegate out startup to the micromanagement server so these actions // will occur after we have obtained our socket. usefulLameDuckPeriod := float64(config.QueryTimeout + 1) if usefulLameDuckPeriod > *lameDuckPeriod { *lameDuckPeriod = usefulLameDuckPeriod relog.Info("readjusted -lame-duck-period to %f", *lameDuckPeriod) } umgmt.SetLameDuckPeriod(float32(*lameDuckPeriod)) umgmt.SetRebindDelay(float32(*rebindDelay)) umgmt.AddStartupCallback(func() { umgmt.StartHttpServer(fmt.Sprintf(":%v", config.Port)) }) umgmt.AddStartupCallback(func() { sighandler.SetSignalHandler(syscall.SIGTERM, umgmt.SigTermHandler) }) umgmt.AddCloseCallback(func() { ts.DisallowQueries() }) umgmt.AddShutdownCallback(func() error { HandleGracefulShutdown() return nil }) umgmtSocket := fmt.Sprintf(config.UmgmtSocket, config.Port) if umgmtErr := umgmt.ListenAndServe(umgmtSocket); umgmtErr != nil { relog.Error("umgmt.ListenAndServe err: %v", umgmtErr) } relog.Info("done") }