func main() { defer exit.Recover() 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.Errorf("ListenAndServe: %s", err) exit.Return(1) } }() } zconn := zk.NewMetaConn() 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) } 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.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 exit.RecoverAll() defer logutil.Flush() flag.Parse() args := flag.Args() if len(args) != 0 { flag.Usage() os.Exit(1) } if *fromTopo == "" || *toTopo == "" { log.Errorf("Need both from and to topo") exit.Return(1) } ctx := context.Background() fromTS := topo.GetServerByName(*fromTopo) toTS := topo.GetServerByName(*toTopo) if *doKeyspaces { helpers.CopyKeyspaces(ctx, fromTS.Impl, toTS.Impl) } if *doShards { helpers.CopyShards(ctx, fromTS.Impl, toTS.Impl, *deleteKeyspaceShards) } if *doShardReplications { helpers.CopyShardReplications(ctx, fromTS.Impl, toTS.Impl) } if *doTablets { helpers.CopyTablets(ctx, fromTS.Impl, toTS.Impl) } }
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 main() { defer exit.Recover() 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() exit.Return(1) } if *zkAddrs != "" { var err error zconn, _, err = zk.DialZkTimeout(*zkAddrs, 5*time.Second, 10*time.Second) if err != nil { log.Errorf("zk connect failed: %v", err.Error()) exit.Return(1) } } cmdName := args[0] args = args[1:] if cmd, ok := cmdMap[cmdName]; ok { subFlags := flag.NewFlagSet(cmdName, flag.ExitOnError) if err := cmd(subFlags, args); err != nil { log.Error(err) exit.Return(1) } } }
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 exit.Recover() defer logutil.Flush() flag.Parse() args := flag.Args() if len(args) == 0 { flag.Usage() exit.Return(1) } if *cpuProfile != "" { f, err := os.Create(*cpuProfile) if err != nil { log.Error(err) exit.Return(1) } pprof.StartCPUProfile(f) defer pprof.StopCPUProfile() } ctx := context.Background() if *mode == "getSrvKeyspaceNames" { rpcClient := connect() if len(args) == 1 { getSrvKeyspaceNames(ctx, rpcClient, args[0], true) } else { log.Errorf("getSrvKeyspaceNames only takes one argument") exit.Return(1) } } else if *mode == "getSrvKeyspace" { rpcClient := connect() if len(args) == 2 { getSrvKeyspace(ctx, rpcClient, args[0], args[1], true) } else { log.Errorf("getSrvKeyspace only takes two arguments") exit.Return(1) } } else if *mode == "getEndPoints" { rpcClient := connect() if len(args) == 4 { getEndPoints(ctx, rpcClient, args[0], args[1], args[2], args[3], true) } else { log.Errorf("getEndPoints only takes four arguments") exit.Return(1) } } else if *mode == "qps" { qps(ctx, args[0], args[1:]) } else { flag.Usage() log.Errorf("Invalid mode: %v", *mode) exit.Return(1) } }
func main() { defer exit.Recover() flag.Parse() args := flag.Args() servenv.Init() defer servenv.Close() ts := topo.GetServer() defer topo.CloseServers() wi = worker.NewInstance(ts, *cell, *commandDisplayInterval) wi.InstallSignalHandlers() wi.InitStatusHandling() if len(args) == 0 { // In interactive mode, initialize the web UI to choose a command. wi.InitInteractiveMode() } else { // In single command mode, just run it. worker, done, err := wi.RunCommand(context.Background(), args, nil /*custom wrangler*/, true /*runFromCli*/) if err != nil { log.Error(err) exit.Return(1) } // Run the subsequent, blocking wait asynchronously. go func() { if err := wi.WaitForCommand(worker, done); err != nil { log.Error(err) logutil.Flush() // We cannot use exit.Return() here because we are in a different go routine now. os.Exit(1) } logutil.Flush() os.Exit(0) }() } servenv.RunDefault() }
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) actionPath, 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) } if actionPath != "" { if *noWaitForAction { fmt.Println(actionPath) } else { err := wr.WaitForCompletion(actionPath) if err != nil { log.Error(err.Error()) exit.Return(255) } else { log.Infof("action completed: %v", actionPath) } } } }
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() 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 var waitForSignal bool switch action { case "init": err = zkd.Init() waitForSignal = *follow case "shutdown": err = zkd.Shutdown() case "start": err = zkd.Start() waitForSignal = *follow case "teardown": err = zkd.Teardown() default: log.Fatalf("invalid action: %v", action) } if err != nil { log.Fatalf("failed %v: %v", action, err) } if waitForSignal { 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() 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 exit.Recover() 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(dbconfigFlags) flag.Parse() tabletAddr = netutil.JoinHostPort("localhost", int32(*port)) 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() } if err := cmd.method(subFlags, flag.Args()[1:]); err != nil { log.Error(err) exit.Return(1) } return } } log.Errorf("invalid action: %v", action) exit.Return(1) }
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] 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() ctx, cancel := context.WithTimeout(context.Background(), *waitTime) wr := wrangler.New(logutil.NewConsoleLogger(), topoServer, tmclient.NewTabletManagerClient(), *lockWaitTimeout) installSignalHandlers(cancel) for _, f := range initFuncs { f() } err := vtctl.RunCommand(ctx, wr, args) cancel() 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() 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 TestError(t *testing.T) { env := setup("echo ERROR expected error $* 1>&2", 1) defer cleanup(env) mbl := &MysqlBinlog{} out, err := mbl.Launch("db", "name", 10) if err != nil { panic(err) } ioutil.ReadAll(out) mbl.Wait() logutil.Flush() warnbytes, err := ioutil.ReadFile(path.Join(os.TempDir(), "binlog.test.INFO")) if err != nil { t.Error(err) } got := string(warnbytes) want := "ERROR expected error --database=db --start-position=10 name" if !strings.Contains(got, want) { t.Errorf("want '%s' in '%s'", want, got) } }
func main() { defer exit.Recover() defer logutil.Flush() flags := dbconfigs.AppConfig | dbconfigs.DbaConfig | dbconfigs.FilteredConfig | dbconfigs.ReplConfig dbconfigs.RegisterFlags(flags) flag.Parse() mycnf := mysqlctl.NewMycnf(uint32(*tabletUID), int32(*mysqlPort)) if *mysqlSocket != "" { mycnf.SocketFile = *mysqlSocket } dbcfgs, err := dbconfigs.Init(mycnf.SocketFile, flags) if err != nil { log.Errorf("%v", err) exit.Return(255) } mysqld = mysqlctl.NewMysqld("Dba", "App", mycnf, &dbcfgs.Dba, &dbcfgs.App.ConnParams, &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. ctx, cancel := context.WithTimeout(context.Background(), *waitTime) if _, err = os.Stat(mycnf.DataDir); os.IsNotExist(err) { log.Infof("mysql data dir (%s) doesn't exist, initializing", mycnf.DataDir) mysqld.Init(ctx, *initDBSQLFile) } else { log.Infof("mysql data dir (%s) already exists, starting without init", mycnf.DataDir) mysqld.Start(ctx) } cancel() 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") ctx := context.Background() mysqld.Shutdown(ctx, false) }) // 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 exit.Recover() defer logutil.Flush() flag.Parse() args := flag.Args() if len(args) == 0 { flag.Usage() exit.Return(1) } connStr := fmt.Sprintf(`{"address": "%s", "tablet_type": "%s", "streaming": %v, "timeout": %d}`, *server, *tabletType, *streaming, int64(30*(*timeout))) db, err := sql.Open("vitess", connStr) if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } log.Infof("Sending the query...") now := time.Now() // handle dml if isDml(args[0]) { tx, err := db.Begin() if err != nil { log.Errorf("begin failed: %v", err) exit.Return(1) } result, err := db.Exec(args[0], []interface{}(*bindVariables)...) if err != nil { log.Errorf("exec failed: %v", err) exit.Return(1) } err = tx.Commit() if err != nil { log.Errorf("commit failed: %v", err) exit.Return(1) } rowsAffected, err := result.RowsAffected() lastInsertId, err := result.LastInsertId() log.Infof("Total time: %v / Row affected: %v / Last Insert Id: %v", time.Now().Sub(now), rowsAffected, lastInsertId) } else { // launch the query rows, err := db.Query(args[0], []interface{}(*bindVariables)...) if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } defer rows.Close() // print the headers cols, err := rows.Columns() if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } line := "Index" for _, field := range cols { line += "\t" + field } fmt.Printf("%s\n", line) // get the rows rowIndex := 0 for rows.Next() { row := make([]interface{}, len(cols)) for i := range row { var col string row[i] = &col } if err := rows.Scan(row...); err != nil { log.Errorf("client error: %v", err) exit.Return(1) } // print the line line := fmt.Sprintf("%d", rowIndex) for _, value := range row { line += fmt.Sprintf("\t%v", *(value.(*string))) } fmt.Printf("%s\n", line) rowIndex++ } if err := rows.Err(); err != nil { log.Errorf("Error %v\n", err) exit.Return(1) } log.Infof("Total time: %v / Row count: %v", time.Now().Sub(now), rowIndex) } }
func main() { defer exit.Recover() defer logutil.Flush() dbconfigFlags := dbconfigs.AppConfig | dbconfigs.DbaConfig | dbconfigs.FilteredConfig | dbconfigs.ReplConfig dbconfigs.RegisterFlags(dbconfigFlags) flag.Parse() // We'll register this 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{}) onTermFunc := func() { close(mysqldTerminated) } // Start or Init mysqld as needed. ctx, cancel := context.WithTimeout(context.Background(), *waitTime) tabletDir := mysqlctl.TabletDir(uint32(*tabletUID)) if _, statErr := os.Stat(tabletDir); os.IsNotExist(statErr) { // Generate my.cnf from scratch and use it to find mysqld. log.Infof("tablet dir (%s) doesn't exist, initializing", tabletDir) var err error mysqld, err = mysqlctl.CreateMysqld(uint32(*tabletUID), *mysqlSocket, int32(*mysqlPort), dbconfigFlags) if err != nil { log.Errorf("failed to initialize mysql config: %v", err) exit.Return(1) } mysqld.OnTerm(onTermFunc) if err := mysqld.Init(ctx, *initDBSQLFile); err != nil { log.Errorf("failed to initialize mysql data dir and start mysqld: %v", err) exit.Return(1) } } else { // There ought to be an existing my.cnf, so use it to find mysqld. log.Infof("tablet dir (%s) already exists, starting without init", tabletDir) var err error mysqld, err = mysqlctl.OpenMysqld(uint32(*tabletUID), dbconfigFlags) if err != nil { log.Errorf("failed to find mysql config: %v", err) exit.Return(1) } mysqld.OnTerm(onTermFunc) if err := mysqld.Start(ctx); err != nil { log.Errorf("failed to start mysqld: %v", err) exit.Return(1) } } cancel() 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") ctx := context.Background() mysqld.Shutdown(ctx, false) }) // 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 exit.Recover() defer logutil.Flush() flag.Parse() args := flag.Args() if len(args) == 0 { flag.Usage() exit.Return(1) } c := vitessdriver.Configuration{ Protocol: *vtgateconn.VtgateProtocol, Address: *server, Keyspace: *keyspace, Shard: *shard, TabletType: *tabletType, Timeout: *timeout, Streaming: *streaming, } db, err := vitessdriver.OpenWithConfiguration(c) if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } log.Infof("Sending the query...") startTime := time.Now() // handle dml if isDml(args[0]) { tx, err := db.Begin() if err != nil { log.Errorf("begin failed: %v", err) exit.Return(1) } result, err := db.Exec(args[0], []interface{}(*bindVariables)...) if err != nil { log.Errorf("exec failed: %v", err) exit.Return(1) } err = tx.Commit() if err != nil { log.Errorf("commit failed: %v", err) exit.Return(1) } rowsAffected, err := result.RowsAffected() lastInsertID, err := result.LastInsertId() log.Infof("Total time: %v / Row affected: %v / Last Insert Id: %v", time.Since(startTime), rowsAffected, lastInsertID) } else { // launch the query rows, err := db.Query(args[0], []interface{}(*bindVariables)...) if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } defer rows.Close() // get the headers var qr results cols, err := rows.Columns() if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } qr.Fields = cols // get the rows for rows.Next() { row := make([]interface{}, len(cols)) for i := range row { var col string row[i] = &col } if err := rows.Scan(row...); err != nil { log.Errorf("client error: %v", err) exit.Return(1) } // unpack []*string into []string vals := make([]string, 0, len(row)) for _, value := range row { vals = append(vals, *(value.(*string))) } qr.Rows = append(qr.Rows, vals) } if err := rows.Err(); err != nil { log.Errorf("Error %v\n", err) exit.Return(1) } if *jsonOutput { data, err := json.MarshalIndent(qr, "", " ") if err != nil { log.Errorf("cannot marshal data: %v", err) exit.Return(1) } fmt.Print(string(data)) } else { printTable(qr, time.Since(startTime)) } } }
func main() { defer exit.Recover() defer logutil.Flush() flag.Parse() args := flag.Args() if len(args) == 0 { flag.Usage() exit.Return(1) } c := vitessdriver.Configuration{ Protocol: *vtgateconn.VtgateProtocol, Address: *server, Keyspace: *keyspace, Shard: *shard, TabletType: *tabletType, Timeout: *timeout, Streaming: *streaming, } db, err := vitessdriver.OpenWithConfiguration(c) if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } log.Infof("Sending the query...") now := time.Now() // handle dml if isDml(args[0]) { tx, err := db.Begin() if err != nil { log.Errorf("begin failed: %v", err) exit.Return(1) } result, err := db.Exec(args[0], []interface{}(*bindVariables)...) if err != nil { log.Errorf("exec failed: %v", err) exit.Return(1) } err = tx.Commit() if err != nil { log.Errorf("commit failed: %v", err) exit.Return(1) } rowsAffected, err := result.RowsAffected() lastInsertID, err := result.LastInsertId() log.Infof("Total time: %v / Row affected: %v / Last Insert Id: %v", time.Now().Sub(now), rowsAffected, lastInsertID) } else { // launch the query rows, err := db.Query(args[0], []interface{}(*bindVariables)...) if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } defer rows.Close() // print the headers cols, err := rows.Columns() if err != nil { log.Errorf("client error: %v", err) exit.Return(1) } line := "Index" for _, field := range cols { line += "\t" + field } fmt.Printf("%s\n", line) // get the rows rowIndex := 0 for rows.Next() { row := make([]interface{}, len(cols)) for i := range row { var col string row[i] = &col } if err := rows.Scan(row...); err != nil { log.Errorf("client error: %v", err) exit.Return(1) } // print the line line := fmt.Sprintf("%d", rowIndex) for _, value := range row { line += fmt.Sprintf("\t%v", *(value.(*string))) } fmt.Printf("%s\n", line) rowIndex++ } if err := rows.Err(); err != nil { log.Errorf("Error %v\n", err) exit.Return(1) } 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) } }
func main() { defer exit.Recover() 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") } flags := dbconfigs.AppConfig | dbconfigs.DbaConfig | dbconfigs.FilteredConfig | dbconfigs.ReplConfig dbconfigs.RegisterFlags(flags) flag.Parse() tabletAddr = netutil.JoinHostPort("localhost", int32(*port)) mycnf := mysqlctl.NewMycnf(uint32(*tabletUID), int32(*mysqlPort)) if *mysqlSocket != "" { mycnf.SocketFile = *mysqlSocket } dbcfgs, err := dbconfigs.Init(mycnf.SocketFile, flags) if err != nil { log.Errorf("%v", err) exit.Return(1) } mysqld := mysqlctl.NewMysqld("Dba", "App", mycnf, &dbcfgs.Dba, &dbcfgs.App.ConnParams, &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() } if err := cmd.method(mysqld, subFlags, flag.Args()[1:]); err != nil { log.Error(err) exit.Return(1) } return } } log.Errorf("invalid action: %v", action) exit.Return(1) }
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) } }