func main() {
defer exit.Recover()
defer logutil.Flush()
flag.Parse()
zkConfig := zkctl.MakeZkConfigFromString(*zkCfg, uint32(*myId))
zkd := zkctl.NewZkd(zkConfig)
if zkd.Inited() {
log.Infof("already initialized, starting without init...")
if err := zkd.Start(); err != nil {
log.Errorf("failed start: %v", err)
exit.Return(255)
}
} else {
log.Infof("initializing...")
if err := zkd.Init(); err != nil {
log.Errorf("failed init: %v", err)
exit.Return(255)
}
}
log.Infof("waiting for signal or server shutdown...")
sig := make(chan os.Signal)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
select {
case <-zkd.Done():
log.Infof("server shut down on its own")
case <-sig:
log.Infof("signal received, shutting down server")
zkd.Shutdown()
}
}
func main() {
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) == 0 {
flag.Usage()
os.Exit(1)
}
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 main() {
defer exit.RecoverAll()
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) != 0 {
flag.Usage()
os.Exit(1)
}
if *fromTopo == "" || *toTopo == "" {
log.Fatalf("Need both from and to topo")
}
fromTS := topo.GetServerByName(*fromTopo)
toTS := topo.GetServerByName(*toTopo)
if *doKeyspaces {
helpers.CopyKeyspaces(fromTS, toTS)
}
if *doShards {
helpers.CopyShards(fromTS, toTS, *deleteKeyspaceShards)
}
if *doShardReplications {
helpers.CopyShardReplications(fromTS, toTS)
}
if *doTablets {
helpers.CopyTablets(fromTS, toTS)
}
}
func init() {
onInit(func() {
http.HandleFunc("/debug/flushlogs", func(w http.ResponseWriter, r *http.Request) {
logutil.Flush()
fmt.Fprint(w, "flushed")
})
})
}
func main() {
defer exit.Recover()
defer logutil.Flush()
dbconfigs.RegisterFlags()
flag.Parse()
mycnf := mysqlctl.NewMycnf(uint32(*tabletUid), *mysqlPort)
if *mysqlSocket != "" {
mycnf.SocketFile = *mysqlSocket
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile)
if err != nil {
log.Errorf("%v", err)
exit.Return(255)
}
mysqld = mysqlctl.NewMysqld("Dba", mycnf, &dbcfgs.Dba, &dbcfgs.Repl)
// Register OnTerm handler before mysqld starts, so we get notified if mysqld
// dies on its own without us (or our RPC client) telling it to.
mysqldTerminated := make(chan struct{})
mysqld.OnTerm(func() {
close(mysqldTerminated)
})
// Start or Init mysqld as needed.
if _, err = os.Stat(mycnf.DataDir); os.IsNotExist(err) {
log.Infof("mysql data dir (%s) doesn't exist, initializing", mycnf.DataDir)
mysqld.Init(*waitTime, *bootstrapArchive, *skipSchema)
} else {
log.Infof("mysql data dir (%s) already exists, starting without init", mycnf.DataDir)
mysqld.Start(*waitTime)
}
servenv.Init()
defer servenv.Close()
// Take mysqld down with us on SIGTERM before entering lame duck.
servenv.OnTerm(func() {
log.Infof("mysqlctl received SIGTERM, shutting down mysqld first")
mysqld.Shutdown(false, 0)
})
// Start RPC server and wait for SIGTERM.
mysqlctldTerminated := make(chan struct{})
go func() {
servenv.RunDefault()
close(mysqlctldTerminated)
}()
select {
case <-mysqldTerminated:
log.Infof("mysqld shut down on its own, exiting mysqlctld")
case <-mysqlctldTerminated:
log.Infof("mysqlctld shut down gracefully")
}
}
func main() {
defer logutil.Flush()
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: %s [global parameters] command [command parameters]\n", os.Args[0])
fmt.Fprintf(os.Stderr, "\nThe global optional parameters are:\n")
flag.PrintDefaults()
fmt.Fprintf(os.Stderr, "\nThe commands are listed below. Use '%s <command> -h' for more help.\n\n", os.Args[0])
for _, cmd := range commands {
fmt.Fprintf(os.Stderr, " %s", cmd.name)
if cmd.params != "" {
fmt.Fprintf(os.Stderr, " %s", cmd.params)
}
fmt.Fprintf(os.Stderr, "\n")
}
fmt.Fprintf(os.Stderr, "\n")
}
dbconfigs.RegisterFlags()
flag.Parse()
tabletAddr = fmt.Sprintf("%v:%v", "localhost", *port)
mycnf := mysqlctl.NewMycnf(uint32(*tabletUid), *mysqlPort)
if *mysqlSocket != "" {
mycnf.SocketFile = *mysqlSocket
}
dbcfgs, err := dbconfigs.Init(mycnf.SocketFile)
if err != nil {
log.Fatalf("%v", err)
}
mysqld := mysqlctl.NewMysqld("Dba", mycnf, &dbcfgs.Dba, &dbcfgs.Repl)
defer mysqld.Close()
action := flag.Arg(0)
for _, cmd := range commands {
if cmd.name == action {
subFlags := flag.NewFlagSet(action, flag.ExitOnError)
subFlags.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage: %s %s %s\n\n", os.Args[0], cmd.name, cmd.params)
fmt.Fprintf(os.Stderr, "%s\n\n", cmd.help)
subFlags.PrintDefaults()
}
cmd.method(mysqld, subFlags, flag.Args()[1:])
return
}
}
log.Fatalf("invalid action: %v", action)
}
func main() {
defer logutil.Flush()
dbconfigs.RegisterFlags()
flag.Parse()
dbcfgs, err := dbconfigs.Init(*mysqlSocketFile)
if err != nil {
log.Fatalf("Failed to init dbconfigs: %v", err)
}
pc := primecache.NewPrimeCache(dbcfgs, *relayLogsPath)
pc.WorkerCount = *workerCount
pc.SleepDuration = *sleepDuration
pc.Loop()
}
func main() {
defer logutil.Flush()
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %v:\n", os.Args[0])
flag.PrintDefaults()
fmt.Fprintf(os.Stderr, doc)
}
flag.Parse()
args := flag.Args()
if len(args) == 0 {
flag.Usage()
os.Exit(1)
}
if *zkAddrs != "" {
if *zkoccAddr != "" {
log.Fatalf("zk.addrs and zk.zkocc-addr are mutually exclusive")
}
var err error
zconn, _, err = zk.DialZkTimeout(*zkAddrs, 5*time.Second, 10*time.Second)
if err != nil {
log.Fatalf("zk connect failed: %v", err.Error())
}
}
if *zkoccAddr != "" {
var err error
zconn, err = zk.DialZkocc(*zkoccAddr, 5*time.Second)
if err != nil {
log.Fatalf("zkocc connect failed: %v", err.Error())
}
}
cmdName := args[0]
args = args[1:]
if cmd, ok := cmdMap[cmdName]; ok {
subFlags := flag.NewFlagSet(cmdName, flag.ExitOnError)
cmd(subFlags, args)
}
}
func main() {
defer exit.RecoverAll()
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) == 0 {
flag.Usage()
exit.Return(1)
}
action := args[0]
installSignalHandlers()
startMsg := fmt.Sprintf("USER=%v SUDO_USER=%v %v", os.Getenv("USER"), os.Getenv("SUDO_USER"), strings.Join(os.Args, " "))
if syslogger, err := syslog.New(syslog.LOG_INFO, "vtctl "); err == nil {
syslogger.Info(startMsg)
} else {
log.Warningf("cannot connect to syslog: %v", err)
}
topoServer := topo.GetServer()
defer topo.CloseServers()
wr := wrangler.New(logutil.NewConsoleLogger(), topoServer, *waitTime, *lockWaitTimeout)
err := vtctl.RunCommand(wr, args)
switch err {
case vtctl.ErrUnknownCommand:
flag.Usage()
exit.Return(1)
case nil:
// keep going
default:
log.Errorf("action failed: %v %v", action, err)
exit.Return(255)
}
}
func main() {
defer logutil.Flush()
zknsDomain := flag.String("zkns-domain", "", "The naming hierarchy portion to serve")
zknsRoot := flag.String("zkns-root", "", "The root path from which to resolve")
bindAddr := flag.String("bind-addr", ":31981", "Bind the debug http server")
flag.Parse()
if *bindAddr != "" {
go func() {
err := http.ListenAndServe(*bindAddr, nil)
if err != nil {
log.Fatalf("ListenAndServe: %s", err)
}
}()
}
zconn := zk.NewMetaConn(false)
fqdn := netutil.FullyQualifiedHostnameOrPanic()
zr1 := newZknsResolver(zconn, fqdn, *zknsDomain, *zknsRoot)
pd := &pdns{zr1}
pd.Serve(os.Stdin, os.Stdout)
os.Stdout.Close()
}
func main() {
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) == 0 {
flag.Usage()
os.Exit(1)
}
client2.RegisterShardedDrivers()
conn, err := db.Open(*driver, *server)
if err != nil {
log.Fatalf("client error: %v", err)
}
log.Infof("Sending the query...")
now := time.Now()
// handle dml
if isDml(args[0]) {
t, err := conn.Begin()
if err != nil {
log.Fatalf("begin failed: %v", err)
}
r, err := conn.Exec(args[0], bindvars)
if err != nil {
log.Fatalf("exec failed: %v", err)
}
err = t.Commit()
if err != nil {
log.Fatalf("commit failed: %v", err)
}
n, err := r.RowsAffected()
log.Infof("Total time: %v / Row affected: %v", time.Now().Sub(now), n)
} else {
// launch the query
r, err := conn.Exec(args[0], bindvars)
if err != nil {
log.Fatalf("client error: %v", err)
}
// get the headers
cols := r.Columns()
if err != nil {
log.Fatalf("client error: %v", err)
}
// print the header
if *verbose {
line := "Index"
for _, field := range cols {
line += "\t" + field
}
log.Infof(line)
}
// get the rows
rowIndex := 0
for row := r.Next(); row != nil; row = r.Next() {
// print the line if needed
if *verbose {
line := fmt.Sprintf("%d", rowIndex)
for _, value := range row {
if value != nil {
switch value.(type) {
case []byte:
line += fmt.Sprintf("\t%s", value)
default:
line += fmt.Sprintf("\t%v", value)
}
} else {
line += "\t"
}
}
log.Infof(line)
}
rowIndex++
}
if err := r.Err(); err != nil {
log.Fatalf("Error %v\n", err)
}
log.Infof("Total time: %v / Row count: %v", time.Now().Sub(now), rowIndex)
}
}
func main() {
defer logutil.Flush()
flag.Parse()
args := flag.Args()
if len(args) == 0 {
flag.Usage()
os.Exit(1)
}
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
if *mode == "get" {
rpcClient := connect()
if len(args) == 1 {
get(rpcClient, args[0], true)
} else {
getv(rpcClient, args, true)
}
} else if *mode == "children" {
rpcClient := connect()
children(rpcClient, args, true)
} else if *mode == "getSrvKeyspaceNames" {
rpcClient := connect()
if len(args) == 1 {
getSrvKeyspaceNames(rpcClient, args[0], true)
} else {
log.Fatalf("getSrvKeyspaceNames only takes one argument")
}
} else if *mode == "getSrvKeyspace" {
rpcClient := connect()
if len(args) == 2 {
getSrvKeyspace(rpcClient, args[0], args[1], true)
} else {
log.Fatalf("getSrvKeyspace only takes two arguments")
}
} else if *mode == "getEndPoints" {
rpcClient := connect()
if len(args) == 4 {
getEndPoints(rpcClient, args[0], args[1], args[2], args[3], true)
} else {
log.Fatalf("getEndPoints only takes four arguments")
}
} else if *mode == "qps" {
qps(args)
} else if *mode == "qps2" {
qps2(args[0], args[1:])
} else {
flag.Usage()
log.Fatalf("Invalid mode: %v", *mode)
}
}
