func main() {
dbConfigsFile, dbCredentialsFile := dbconfigs.RegisterCommonFlags()
flag.Parse()
relog.Info("started vtaction %v", os.Args)
rpc.HandleHTTP()
jsonrpc.ServeHTTP()
jsonrpc.ServeRPC()
bsonrpc.ServeHTTP()
bsonrpc.ServeRPC()
logFile, err := os.OpenFile(*logFilename,
os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
relog.Fatal("Can't open log file: %v", err)
}
relog.SetOutput(logFile)
relog.SetPrefix(fmt.Sprintf("vtaction [%v] ", os.Getpid()))
if err := relog.SetLevelByName(*logLevel); err != nil {
relog.Fatal("%v", err)
}
relog.HijackLog(nil)
relog.HijackStdio(logFile, logFile)
mycnf, mycnfErr := mysqlctl.ReadMycnf(*mycnfFile)
if mycnfErr != nil {
relog.Fatal("mycnf read failed: %v", mycnfErr)
}
relog.Debug("mycnf: %v", jscfg.ToJson(mycnf))
dbcfgs, cfErr := dbconfigs.Init(mycnf.SocketFile, *dbConfigsFile, *dbCredentialsFile)
if err != nil {
relog.Fatal("%s", cfErr)
}
mysqld := mysqlctl.NewMysqld(mycnf, dbcfgs.Dba, dbcfgs.Repl)
topoServer := topo.GetServer()
defer topo.CloseServers()
actor := tabletmanager.NewTabletActor(mysqld, topoServer)
// we delegate out startup to the micromanagement server so these actions
// will occur after we have obtained our socket.
bindAddr := fmt.Sprintf(":%v", *port)
httpServer := &http.Server{Addr: bindAddr}
go func() {
if err := httpServer.ListenAndServe(); err != nil {
relog.Error("httpServer.ListenAndServe err: %v", err)
}
}()
actionErr := actor.HandleAction(*actionNode, *action, *actionGuid, *force)
if actionErr != nil {
relog.Fatal("action error: %v", actionErr)
}
relog.Info("finished vtaction %v", os.Args)
}
func main() {
flag.Parse()
args := flag.Args()
if len(args) == 0 {
flag.Usage()
os.Exit(1)
}
relog.SetPrefix("zkctl ")
if err := relog.SetLevelByName(*logLevel); err != nil {
log.Fatal(err)
}
zkConfig := zkctl.MakeZkConfigFromString(*zkCfg, uint32(*myId))
zkd := zkctl.NewZkd(zkConfig)
action := flag.Arg(0)
var err error
switch action {
case "init":
err = zkd.Init()
case "shutdown":
err = zkd.Shutdown()
case "start":
err = zkd.Start()
case "teardown":
err = zkd.Teardown()
default:
log.Fatalf("invalid action: %v", action)
}
if err != nil {
log.Fatalf("failed %v: %v", action, err)
}
}
func Init(logPrefix string) error {
// Once you run as root, you pretty much destroy the chances of a
// non-privileged user starting the program correctly.
if uid := os.Getuid(); uid == 0 {
return fmt.Errorf("running this as root makes no sense")
}
if logPrefix != "" {
logPrefix += " "
}
logPrefix += fmt.Sprintf("[%v] ", os.Getpid())
f, err := logfile.Open(*logfileName, *logFrequency, *logMaxSize, *logMaxFiles)
if err != nil {
return fmt.Errorf("unable to open logfile %s: %v", *logfileName, err)
}
relog.SetOutput(f)
relog.SetPrefix(logPrefix)
relog.SetLevel(relog.DEBUG)
relog.HijackLog(nil)
// FIXME(msolomon) Can't hijack with a logfile because the file descriptor
// changes after every rotation. Might need to make the logfile more posix
// friendly.
//relog.HijackStdio(f, f)
runtime.MemProfileRate = *memProfileRate
gomaxprocs := os.Getenv("GOMAXPROCS")
if gomaxprocs == "" {
gomaxprocs = "1"
}
// Could report this in an expvar instead.
relog.Info("GOMAXPROCS = %v", gomaxprocs)
// We used to set this limit directly, but you pretty much have to
// use a root account to allow increasing a limit reliably. Dropping
// privileges is also tricky. The best strategy is to make a shell
// script set up the limits as root and switch users before starting
// the server.
fdLimit := &syscall.Rlimit{}
if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, fdLimit); err != nil {
relog.Error("max-open-fds failed: %v", err)
} else {
// Could report this in an expvar instead.
relog.Info("max-open-fds: %v", fdLimit.Cur)
}
return exportBinaryVersion()
}