// ApplyWithError populates the flag given the flag set and environment func (f IntFlag) ApplyWithError(set *flag.FlagSet) error { if f.EnvVar != "" { for _, envVar := range strings.Split(f.EnvVar, ",") { envVar = strings.TrimSpace(envVar) if envVal, ok := syscall.Getenv(envVar); ok { envValInt, err := strconv.ParseInt(envVal, 0, 64) if err != nil { return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err) } f.Value = int(envValInt) break } } } eachName(f.Name, func(name string) { if f.Destination != nil { set.IntVar(f.Destination, name, f.Value, f.Usage) return } set.Int(name, f.Value, f.Usage) }) return nil }
func (cmd *pullCmd) Flags(fs *flag.FlagSet) *flag.FlagSet { cmd.noClobber = fs.Bool(drive.CLIOptionNoClobber, false, "prevents overwriting of old content") cmd.export = fs.String( "export", "", "comma separated list of formats to export your docs + sheets files") cmd.recursive = fs.Bool("r", true, "performs the pull action recursively") cmd.noPrompt = fs.Bool(drive.NoPromptKey, false, "shows no prompt before applying the pull action") cmd.hidden = fs.Bool(drive.HiddenKey, false, "allows pulling of hidden paths") cmd.force = fs.Bool(drive.ForceKey, false, "forces a pull even if no changes present") cmd.ignoreChecksum = fs.Bool(drive.CLIOptionIgnoreChecksum, true, drive.DescIgnoreChecksum) cmd.ignoreConflict = fs.Bool(drive.CLIOptionIgnoreConflict, false, drive.DescIgnoreConflict) cmd.ignoreNameClashes = fs.Bool(drive.CLIOptionIgnoreNameClashes, false, drive.DescIgnoreNameClashes) cmd.exportsDir = fs.String("export-dir", "", "directory to place exports") cmd.matches = fs.Bool(drive.MatchesKey, false, "search by prefix") cmd.piped = fs.Bool("piped", false, "if true, read content from stdin") cmd.quiet = fs.Bool(drive.QuietKey, false, "if set, do not log anything but errors") cmd.excludeOps = fs.String(drive.CLIOptionExcludeOperations, "", drive.DescExcludeOps) cmd.byId = fs.Bool(drive.CLIOptionId, false, "pull by id instead of path") cmd.skipMimeKey = fs.String(drive.CLIOptionSkipMime, "", drive.DescSkipMime) cmd.explicitlyExport = fs.Bool(drive.CLIOptionExplicitlyExport, false, drive.DescExplicitylPullExports) cmd.verbose = fs.Bool(drive.CLIOptionVerboseKey, false, drive.DescVerbose) cmd.depth = fs.Int(drive.DepthKey, drive.DefaultMaxTraversalDepth, "max traversal depth") cmd.fixClashes = fs.Bool(drive.CLIOptionFixClashesKey, false, drive.DescFixClashes) return fs }
func TestLoadConfig(t *testing.T) { var flagSet flag.FlagSet a := flagSet.Int("a", -1, "for test") b := flagSet.Bool("b", true, "for test") c := flagSet.String("c", "-1", "for test") da := flagSet.Int("d.a", -1, "for test") dd := flagSet.Bool("d.d", false, "for test") dc := flagSet.String("d.c", "-1", "for test") e := loadConfig("config_test.txt", &flagSet, false) if nil != e { t.Error(e) return } if *a != 1 { t.Error("a != 1") } if !*b { t.Error("b != true") } if "abc" != *c { t.Error("c != \"abc\"") } if *da != 1323 { t.Error("d.a != 1323") } if !*dd { t.Error("db != true") } if "67" != *dc { t.Errorf("dc != \"67\", actual is %s", *dc) } }
func multisnapshotCmd(mysqld *mysqlctl.Mysqld, subFlags *flag.FlagSet, args []string) { concurrency := subFlags.Int("concurrency", 8, "how many compression jobs to run simultaneously") spec := subFlags.String("spec", "-", "shard specification") tablesString := subFlags.String("tables", "", "dump only this comma separated list of tables") skipSlaveRestart := subFlags.Bool("skip-slave-restart", false, "after the snapshot is done, do not restart slave replication") maximumFilesize := subFlags.Uint64("maximum-file-size", 128*1024*1024, "the maximum size for an uncompressed data file") subFlags.Parse(args) if subFlags.NArg() != 2 { relog.Fatal("action multisnapshot requires <db name> <key name>") } shards, err := key.ParseShardingSpec(*spec) if err != nil { relog.Fatal("multisnapshot failed: %v", err) } var tables []string if *tablesString != "" { tables = strings.Split(*tablesString, ",") } filenames, err := mysqld.CreateMultiSnapshot(shards, subFlags.Arg(0), subFlags.Arg(1), tabletAddr, false, *concurrency, tables, *skipSlaveRestart, *maximumFilesize, nil) if err != nil { relog.Fatal("multisnapshot failed: %v", err) } else { relog.Info("manifest locations: %v", filenames) } }
func commandVtGateSplitQuery(ctx context.Context, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) error { server := subFlags.String("server", "", "VtGate server to connect to") bindVariables := newBindvars(subFlags) connectTimeout := subFlags.Duration("connect_timeout", 30*time.Second, "Connection timeout for vtgate client") splitColumn := subFlags.String("split_column", "", "force the use of this column to split the query") splitCount := subFlags.Int("split_count", 16, "number of splits to generate") keyspace := subFlags.String("keyspace", "", "keyspace to send query to") if err := subFlags.Parse(args); err != nil { return err } if subFlags.NArg() != 1 { return fmt.Errorf("the <sql> argument is required for the VtGateSplitQuery command") } vtgateConn, err := vtgateconn.Dial(ctx, *server, *connectTimeout, "") if err != nil { return fmt.Errorf("error connecting to vtgate '%v': %v", *server, err) } defer vtgateConn.Close() r, err := vtgateConn.SplitQuery(ctx, *keyspace, subFlags.Arg(0), *bindVariables, *splitColumn, int64(*splitCount)) if err != nil { return fmt.Errorf("SplitQuery failed: %v", err) } return printJSON(wr.Logger(), r) }
func commandVtGateSplitQuery(ctx context.Context, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) error { server := subFlags.String("server", "", "VtGate server to connect to") bindVariables := newBindvars(subFlags) connectTimeout := subFlags.Duration("connect_timeout", 30*time.Second, "Connection timeout for vtgate client") splitCount := subFlags.Int("split_count", 16, "number of splits to generate") keyspace := subFlags.String("keyspace", "", "keyspace to send query to") if err := subFlags.Parse(args); err != nil { return err } if subFlags.NArg() != 1 { return fmt.Errorf("the <sql> argument is required for the VtGateSplitQuery command") } vtgateConn, err := vtgateconn.Dial(ctx, *server, *connectTimeout) if err != nil { return fmt.Errorf("error connecting to vtgate '%v': %v", *server, err) } defer vtgateConn.Close() r, err := vtgateConn.SplitQuery(ctx, *keyspace, tproto.BoundQuery{ Sql: subFlags.Arg(0), BindVariables: *bindVariables, }, *splitCount) if err != nil { return fmt.Errorf("SplitQuery failed: %v", err) } wr.Logger().Printf("%v\n", jscfg.ToJSON(r)) return nil }
func (cmd *listCmd) Flags(fs *flag.FlagSet) *flag.FlagSet { cmd.depth = fs.Int(drive.DepthKey, 1, "maximum recursion depth") cmd.hidden = fs.Bool(drive.HiddenKey, false, "list all paths even hidden ones") cmd.files = fs.Bool("f", false, "list only files") cmd.directories = fs.Bool("d", false, "list all directories") cmd.longFmt = fs.Bool("l", false, "long listing of contents") cmd.pageSize = fs.Int64("p", 100, "number of results per pagination") cmd.shared = fs.Bool("shared", false, "show files that are shared with me") cmd.inTrash = fs.Bool(drive.TrashedKey, false, "list content in the trash") cmd.version = fs.Bool("version", false, "show the number of times that the file has been modified on \n\t\tthe server even with changes not visible to the user") cmd.noPrompt = fs.Bool(drive.NoPromptKey, false, "shows no prompt before pagination") cmd.owners = fs.Bool("owners", false, "shows the owner names per file") cmd.recursive = fs.Bool("r", false, "recursively list subdirectories") cmd.sort = fs.String(drive.SortKey, "", drive.DescSort) cmd.matches = fs.Bool(drive.MatchesKey, false, "list by prefix") cmd.quiet = fs.Bool(drive.QuietKey, false, "if set, do not log anything but errors") cmd.skipMimeKey = fs.String(drive.CLIOptionSkipMime, "", drive.DescSkipMime) cmd.matchMimeKey = fs.String(drive.CLIOptionMatchMime, "", drive.DescMatchMime) cmd.exactTitle = fs.String(drive.CLIOptionExactTitle, "", drive.DescExactTitle) cmd.matchOwner = fs.String(drive.CLIOptionMatchOwner, "", drive.DescMatchOwner) cmd.exactOwner = fs.String(drive.CLIOptionExactOwner, "", drive.DescExactOwner) cmd.notOwner = fs.String(drive.CLIOptionNotOwner, "", drive.DescNotOwner) cmd.byId = fs.Bool(drive.CLIOptionId, false, "list by id instead of path") return fs }
func (c *DaemonCmd) Flags(fs *flag.FlagSet) { c.dbfile = fs.String("o", "ci.db", "override the default local file name") c.port = fs.Int("p", 2020, "override the default local port") c.hookport = fs.Int("hp", 2121, "override the default hook port ") c.hook = fs.Bool("hook", false, "also start an http Hook server (Get returns a status, Post fire a build)") }
// NewGoCmdWithFlags like NewGoCmd, but wl also parse flags configured i flagset func NewGoCmdWithFlags(flagset *flag.FlagSet, workdir string, args ...string) (*GoCmd, error) { if len(args) < 2 { return nil, errors.New("GoCmd must have at least two arguments (e.g. go build)") } if sort.SearchStrings([]string{"build", "run", "test"}, args[1]) > -1 { flagset.Int("p", runtime.NumCPU(), "number or parallel builds") for _, f := range []string{"x", "v", "n", "a", "work"} { flagset.Bool(f, false, "") } for _, f := range []string{"compiler", "gccgoflags", "gcflags", "ldflags", "tags"} { flagset.String(f, "", "") } } switch args[1] { case "run": case "build": flagset.String("o", "", "output: output file") case "test": for _, f := range []string{"i", "c"} { flagset.Bool(f, false, "") } for _, testflag := range TestFlags { flagset.String(testflag, "", "") flagset.String("test."+testflag, "", "") } flagset.Bool("short", false, "") flagset.Bool("test.short", false, "") flagset.Bool("test.v", false, "") default: return nil, errors.New("Currently only build run and test commands supported. Sorry.") } if err := flagset.Parse(args[2:]); err != nil { return nil, err } var params, extra []string switch args[1] { case "build": params = flagset.Args() case "run": for i, param := range flagset.Args() { if !strings.HasSuffix(param, ".go") { extra = flagset.Args()[i:] break } params = append(params, param) } case "test": for i, param := range flagset.Args() { if strings.HasPrefix(param, "-") { extra = flagset.Args()[i:] break } params = append(params, param) } default: return nil, errors.New("Currently only build run and test commands supported") } return &GoCmd{make(map[string]string), workdir, args[0], args[1], FromFlagSet(flagset), params, extra}, nil }
func (cmd *md5SumCmd) Flags(fs *flag.FlagSet) *flag.FlagSet { cmd.depth = fs.Int(drive.DepthKey, 1, "maximum recursion depth") cmd.hidden = fs.Bool(drive.HiddenKey, false, "discover hidden paths") cmd.recursive = fs.Bool("r", false, "recursively discover folders") cmd.quiet = fs.Bool(drive.QuietKey, false, "if set, do not log anything but errors") cmd.byId = fs.Bool(drive.CLIOptionId, false, "stat by id instead of path") return fs }
func (cmd *diffCmd) Flags(fs *flag.FlagSet) *flag.FlagSet { cmd.hidden = fs.Bool(drive.HiddenKey, false, "allows pulling of hidden paths") cmd.ignoreChecksum = fs.Bool(drive.CLIOptionIgnoreChecksum, true, drive.DescIgnoreChecksum) cmd.ignoreConflict = fs.Bool(drive.CLIOptionIgnoreConflict, false, drive.DescIgnoreConflict) cmd.ignoreNameClashes = fs.Bool(drive.CLIOptionIgnoreNameClashes, false, drive.DescIgnoreNameClashes) cmd.quiet = fs.Bool(drive.QuietKey, false, "if set, do not log anything but errors") cmd.depth = fs.Int(drive.DepthKey, drive.DefaultMaxTraversalDepth, "max traversal depth") return fs }
func (cmd *statCmd) Flags(fs *flag.FlagSet) *flag.FlagSet { cmd.depth = fs.Int(drive.DepthKey, 1, "max traversal depth") cmd.hidden = fs.Bool(drive.HiddenKey, false, "discover hidden paths") cmd.recursive = fs.Bool("r", false, "recursively discover folders") cmd.quiet = fs.Bool(drive.QuietKey, false, "if set, do not log anything but errors") cmd.byId = fs.Bool(drive.CLIOptionId, false, "stat by id instead of path") cmd.md5sum = fs.Bool(drive.Md5sumKey, false, "produce output compatible with md5sum(1)") return fs }
func (c *flags) addSet(s *flag.FlagSet) { cassandraAddr := s.String("cassandra-addr", "", "Address to a single Cassandra node") c.cassandraAddr = cassandraAddr cassandraRepl := s.Int("cassandra-repl", 1, "Replication factor to use for the oinker keyspace in Cassandra") c.cassandraRepl = cassandraRepl address := s.String("address", "0.0.0.0:8080", "host:port on which to listen") c.address = address }
// Startup flags func (sc *CompareCommand) Flags(fs *flag.FlagSet) *flag.FlagSet { sc.setName = fs.String("s", "", "Select records from this set") sc.beforeDate = fs.String("B", "", "Select records that were updated before date (YYYY-MM-DD)") sc.afterDate = fs.String("A", "", "Select records that were updated after date (YYYY-MM-DD)") sc.firstResult = fs.Int("f", 0, "Index of first record to retrieve") sc.fromFile = fs.String("F", "", "Read identifiers from a file") sc.maxResults = fs.Int("c", 100000, "Maximum number of records to retrieve") sc.compareContent = fs.Bool("C", false, "Compares the metadata content of common metadata records") return fs }
func (a *run_tagger_action) DefineFlags(fs *flag.FlagSet) { a.AddDefaultArgs(fs) a.lexiconPath = fs.String("lexicon_path", "/tmp/tokens", "Path and filename to the lexicon file. One word per line.") a.dbUser = fs.String("db.user", "", "") a.dbPass = fs.String("db.pass", "", "") a.dbName = fs.String("db.name", "", "") a.workers = fs.Int("workers", 10, "Number of workers and db connections to make") }
func (lc *ListCommand) Flags(fs *flag.FlagSet) *flag.FlagSet { lc.setName = fs.String("s", "", "Select records from this set") lc.beforeDate = fs.String("B", "", "Select records that were updated before date (YYYY-MM-DD)") lc.afterDate = fs.String("A", "", "Select records that were updated after date (YYYY-MM-DD)") lc.flagDetailed = fs.Bool("l", false, "Use detailed listing format") lc.showDeleted = fs.Bool("d", false, "Show deleted records, along with active ones") lc.onlyShowDeleted = fs.Bool("D", false, "Only show deleted records") lc.firstResult = fs.Int("f", 0, "Index of first record to retrieve") lc.maxResults = fs.Int("c", 100000, "Maximum number of records to retrieve") lc.listRecords = fs.Bool("R", false, "Use ListRecord instead of ListIdentifier") return fs }
func (f IntFlag) Apply(set *flag.FlagSet) { if f.EnvVar != "" { if envVal := os.Getenv(f.EnvVar); envVal != "" { envValInt, err := strconv.ParseUint(envVal, 10, 64) if err == nil { f.Value = int(envValInt) } } } eachName(f.Name, func(name string) { set.Int(name, f.Value, f.Usage) }) }
func commandLegacySplitClone(wi *Instance, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) (Worker, error) { excludeTables := subFlags.String("exclude_tables", "", "comma separated list of tables to exclude") strategy := subFlags.String("strategy", "", "which strategy to use for restore, use 'vtworker LegacySplitClone --strategy=-help k/s' for more info") sourceReaderCount := subFlags.Int("source_reader_count", defaultSourceReaderCount, "number of concurrent streaming queries to use on the source") destinationPackCount := subFlags.Int("destination_pack_count", defaultDestinationPackCount, "number of packets to pack in one destination insert") destinationWriterCount := subFlags.Int("destination_writer_count", defaultDestinationWriterCount, "number of concurrent RPCs to execute on the destination") minHealthyRdonlyTablets := subFlags.Int("min_healthy_rdonly_tablets", defaultMinHealthyRdonlyTablets, "minimum number of healthy RDONLY tablets before taking out one") maxTPS := subFlags.Int64("max_tps", defaultMaxTPS, "if non-zero, limit copy to maximum number of (write) transactions/second on the destination (unlimited by default)") if err := subFlags.Parse(args); err != nil { return nil, err } if subFlags.NArg() != 1 { subFlags.Usage() return nil, fmt.Errorf("command LegacySplitClone requires <keyspace/shard>") } keyspace, shard, err := topoproto.ParseKeyspaceShard(subFlags.Arg(0)) if err != nil { return nil, err } var excludeTableArray []string if *excludeTables != "" { excludeTableArray = strings.Split(*excludeTables, ",") } worker, err := NewLegacySplitCloneWorker(wr, wi.cell, keyspace, shard, excludeTableArray, *strategy, *sourceReaderCount, *destinationPackCount, *destinationWriterCount, *minHealthyRdonlyTablets, *maxTPS) if err != nil { return nil, fmt.Errorf("cannot create split clone worker: %v", err) } return worker, nil }
func fetchAdditionalCmdLineArgs(cmdLine *flag.FlagSet) CmdLineArgs { args := CmdLineArgs{ File: cmdLine.String("I", "", "file"), Loop: cmdLine.Int("l", 1, "Loop file. 0 - loop forever"), OneAtAtime: cmdLine.Bool("O", false, "Read packets one at a time (press Enter)"), TopSpeed: cmdLine.Bool("t", false, "Read packets as fast as possible, without sleeping"), Dumpfile: cmdLine.String("dump", "", "Write all captured packets to this libpcap file"), PrintDevices: cmdLine.Bool("devices", false, "Print the list of devices and exit"), WaitShutdown: cmdLine.Int("waitstop", 0, "Additional seconds to wait befor shutting down"), } return args }
func snapshotCmd(mysqld *mysqlctl.Mysqld, subFlags *flag.FlagSet, args []string) { concurrency := subFlags.Int("concurrency", 4, "how many compression jobs to run simultaneously") subFlags.Parse(args) if subFlags.NArg() != 1 { relog.Fatal("Command snapshot requires <db name>") } filename, _, _, err := mysqld.CreateSnapshot(subFlags.Arg(0), tabletAddr, false, *concurrency, false, nil) if err != nil { relog.Fatal("snapshot failed: %v", err) } else { relog.Info("manifest location: %v", filename) } }
func commandVerticalSplitClone(wi *Instance, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) (Worker, error) { tables := subFlags.String("tables", "", "comma separated list of tables to replicate (used for vertical split)") strategy := subFlags.String("strategy", "", "which strategy to use for restore, use 'mysqlctl multirestore -strategy=-help' for more info") sourceReaderCount := subFlags.Int("source_reader_count", defaultSourceReaderCount, "number of concurrent streaming queries to use on the source") destinationPackCount := subFlags.Int("destination_pack_count", defaultDestinationPackCount, "number of packets to pack in one destination insert") minTableSizeForSplit := subFlags.Int("min_table_size_for_split", defaultMinTableSizeForSplit, "tables bigger than this size on disk in bytes will be split into source_reader_count chunks if possible") destinationWriterCount := subFlags.Int("destination_writer_count", defaultDestinationWriterCount, "number of concurrent RPCs to execute on the destination") if err := subFlags.Parse(args); err != nil { return nil, err } if subFlags.NArg() != 1 { subFlags.Usage() return nil, fmt.Errorf("command VerticalSplitClone requires <destination keyspace/shard>") } keyspace, shard, err := topo.ParseKeyspaceShardString(subFlags.Arg(0)) if err != nil { return nil, err } var tableArray []string if *tables != "" { tableArray = strings.Split(*tables, ",") } worker, err := NewVerticalSplitCloneWorker(wr, wi.cell, keyspace, shard, tableArray, *strategy, *sourceReaderCount, *destinationPackCount, uint64(*minTableSizeForSplit), *destinationWriterCount) if err != nil { return nil, fmt.Errorf("cannot create worker: %v", err) } return worker, nil }
func commandVerticalSplitDiff(wi *Instance, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) (Worker, error) { minHealthyRdonlyTablets := subFlags.Int("min_healthy_rdonly_tablets", defaultMinHealthyRdonlyTablets, "minimum number of healthy RDONLY tablets before taking out one") if err := subFlags.Parse(args); err != nil { return nil, err } if subFlags.NArg() != 1 { subFlags.Usage() return nil, fmt.Errorf("command VerticalSplitDiff requires <keyspace/shard>") } keyspace, shard, err := topoproto.ParseKeyspaceShard(subFlags.Arg(0)) if err != nil { return nil, err } return NewVerticalSplitDiffWorker(wr, wi.cell, keyspace, shard, *minHealthyRdonlyTablets), nil }
func commandVtTabletExecute(ctx context.Context, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) error { transactionID := subFlags.Int("transaction_id", 0, "transaction id to use, if inside a transaction.") bindVariables := newBindvars(subFlags) keyspace := subFlags.String("keyspace", "", "keyspace the tablet belongs to") shard := subFlags.String("shard", "", "shard the tablet belongs to") tabletType := subFlags.String("tablet_type", "unknown", "tablet type we expect from the tablet (use unknown to use sessionId)") connectTimeout := subFlags.Duration("connect_timeout", 30*time.Second, "Connection timeout for vttablet client") json := subFlags.Bool("json", false, "Output JSON instead of human-readable table") if err := subFlags.Parse(args); err != nil { return err } if subFlags.NArg() != 2 { return fmt.Errorf("the <tablet_alias> and <sql> arguments are required for the VtTabletExecute command") } tt, err := topoproto.ParseTabletType(*tabletType) if err != nil { return err } tabletAlias, err := topoproto.ParseTabletAlias(subFlags.Arg(0)) if err != nil { return err } tabletInfo, err := wr.TopoServer().GetTablet(ctx, tabletAlias) if err != nil { return err } ep, err := topo.TabletEndPoint(tabletInfo.Tablet) if err != nil { return fmt.Errorf("cannot get EndPoint from tablet record: %v", err) } conn, err := tabletconn.GetDialer()(ctx, ep, *keyspace, *shard, tt, *connectTimeout) if err != nil { return fmt.Errorf("cannot connect to tablet %v: %v", tabletAlias, err) } defer conn.Close() qr, err := conn.Execute(ctx, subFlags.Arg(1), *bindVariables, int64(*transactionID)) if err != nil { return fmt.Errorf("Execute failed: %v", err) } if *json { return printJSON(wr.Logger(), qr) } printQueryResult(loggerWriter{wr.Logger()}, qr) return nil }
func partialRestoreCmd(mysqld *mysqlctl.Mysqld, subFlags *flag.FlagSet, args []string) { fetchConcurrency := subFlags.Int("fetch-concurrency", 3, "how many files to fetch simultaneously") fetchRetryCount := subFlags.Int("fetch-retry-count", 3, "how many times to retry a failed transfer") subFlags.Parse(args) if subFlags.NArg() != 1 { relog.Fatal("Command partialrestore requires <split snapshot manifest file>") } rs, err := mysqlctl.ReadSplitSnapshotManifest(subFlags.Arg(0)) if err == nil { err = mysqld.RestoreFromPartialSnapshot(rs, *fetchConcurrency, *fetchRetryCount) } if err != nil { relog.Fatal("partialrestore failed: %v", err) } }
func partialSnapshotCmd(mysqld *mysqlctl.Mysqld, subFlags *flag.FlagSet, args []string) { start := subFlags.String("start", "", "start of the key range") end := subFlags.String("end", "", "end of the key range") concurrency := subFlags.Int("concurrency", 4, "how many compression jobs to run simultaneously") subFlags.Parse(args) if subFlags.NArg() != 2 { relog.Fatal("action partialsnapshot requires <db name> <key name>") } filename, err := mysqld.CreateSplitSnapshot(subFlags.Arg(0), subFlags.Arg(1), key.HexKeyspaceId(*start), key.HexKeyspaceId(*end), tabletAddr, false, *concurrency, nil) if err != nil { relog.Fatal("partialsnapshot failed: %v", err) } else { relog.Info("manifest location: %v", filename) } }
func snapshotSourceStartCmd(mysqld *mysqlctl.Mysqld, subFlags *flag.FlagSet, args []string) { concurrency := subFlags.Int("concurrency", 4, "how many checksum jobs to run simultaneously") subFlags.Parse(args) if subFlags.NArg() != 1 { relog.Fatal("Command snapshotsourcestart requires <db name>") } filename, slaveStartRequired, readOnly, err := mysqld.CreateSnapshot(subFlags.Arg(0), tabletAddr, false, *concurrency, true, nil) if err != nil { relog.Fatal("snapshot failed: %v", err) } else { relog.Info("manifest location: %v", filename) relog.Info("slave start required: %v", slaveStartRequired) relog.Info("read only: %v", readOnly) } }
func commandVtTabletUpdateStream(ctx context.Context, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) error { count := subFlags.Int("count", 1, "number of responses to wait for") timestamp := subFlags.Int("timestamp", 0, "timestamp to start the stream from") position := subFlags.String("position", "", "position to start the stream from") connectTimeout := subFlags.Duration("connect_timeout", 30*time.Second, "Connection timeout for vttablet client") if err := subFlags.Parse(args); err != nil { return err } if subFlags.NArg() != 1 { return fmt.Errorf("The <tablet alias> argument is required for the VtTabletUpdateStream command.") } tabletAlias, err := topoproto.ParseTabletAlias(subFlags.Arg(0)) if err != nil { return err } tabletInfo, err := wr.TopoServer().GetTablet(ctx, tabletAlias) if err != nil { return err } conn, err := tabletconn.GetDialer()(tabletInfo.Tablet, *connectTimeout) if err != nil { return fmt.Errorf("cannot connect to tablet %v: %v", tabletAlias, err) } stream, err := conn.UpdateStream(ctx, &querypb.Target{ Keyspace: tabletInfo.Tablet.Keyspace, Shard: tabletInfo.Tablet.Shard, TabletType: tabletInfo.Tablet.Type, }, *position, int64(*timestamp)) if err != nil { return err } for i := 0; i < *count; i++ { se, err := stream.Recv() if err != nil { return fmt.Errorf("stream ended early: %v", err) } data, err := json.Marshal(se) if err != nil { wr.Logger().Errorf("cannot json-marshal structure: %v", err) } else { wr.Logger().Printf("%v\n", string(data)) } } return nil }
func commandVtTabletStreamHealth(ctx context.Context, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) error { count := subFlags.Int("count", 1, "number of responses to wait for") connectTimeout := subFlags.Duration("connect_timeout", 30*time.Second, "Connection timeout for vttablet client") if err := subFlags.Parse(args); err != nil { return err } if subFlags.NArg() != 1 { return fmt.Errorf("The <tablet alias> argument is required for the VtTabletStreamHealth command.") } tabletAlias, err := topoproto.ParseTabletAlias(subFlags.Arg(0)) if err != nil { return err } tabletInfo, err := wr.TopoServer().GetTablet(ctx, tabletAlias) if err != nil { return err } ep, err := topo.TabletEndPoint(tabletInfo.Tablet) if err != nil { return fmt.Errorf("cannot get EndPoint from tablet record: %v", err) } // pass in a non-UNKNOWN tablet type to not use sessionId conn, err := tabletconn.GetDialer()(ctx, ep, "", "", pb.TabletType_MASTER, *connectTimeout) if err != nil { return fmt.Errorf("cannot connect to tablet %v: %v", tabletAlias, err) } stream, errFunc, err := conn.StreamHealth(ctx) if err != nil { return err } for i := 0; i < *count; i++ { shr, ok := <-stream if !ok { return fmt.Errorf("stream ended early: %v", errFunc()) } data, err := json.Marshal(shr) if err != nil { wr.Logger().Errorf("cannot json-marshal structure: %v", err) } else { wr.Logger().Printf("%v\n", string(data)) } } return nil }
func commandVtTabletExecute(ctx context.Context, wr *wrangler.Wrangler, subFlags *flag.FlagSet, args []string) error { transactionID := subFlags.Int("transaction_id", 0, "transaction id to use, if inside a transaction.") bindVariables := newBindvars(subFlags) connectTimeout := subFlags.Duration("connect_timeout", 30*time.Second, "Connection timeout for vttablet client") options := subFlags.String("options", "", "execute options values as a text encoded proto of the ExecuteOptions structure") json := subFlags.Bool("json", false, "Output JSON instead of human-readable table") if err := subFlags.Parse(args); err != nil { return err } if subFlags.NArg() != 2 { return fmt.Errorf("the <tablet_alias> and <sql> arguments are required for the VtTabletExecute command") } tabletAlias, err := topoproto.ParseTabletAlias(subFlags.Arg(0)) if err != nil { return err } tabletInfo, err := wr.TopoServer().GetTablet(ctx, tabletAlias) if err != nil { return err } executeOptions, err := parseExecuteOptions(*options) if err != nil { return err } conn, err := tabletconn.GetDialer()(tabletInfo.Tablet, *connectTimeout) if err != nil { return fmt.Errorf("cannot connect to tablet %v: %v", tabletAlias, err) } defer conn.Close(ctx) qr, err := conn.Execute(ctx, &querypb.Target{ Keyspace: tabletInfo.Tablet.Keyspace, Shard: tabletInfo.Tablet.Shard, TabletType: tabletInfo.Tablet.Type, }, subFlags.Arg(1), *bindVariables, int64(*transactionID), executeOptions) if err != nil { return fmt.Errorf("Execute failed: %v", err) } if *json { return printJSON(wr.Logger(), qr) } printQueryResult(loggerWriter{wr.Logger()}, qr) return nil }
func restoreCmd(mysqld *mysqlctl.Mysqld, subFlags *flag.FlagSet, args []string) { dontWaitForSlaveStart := subFlags.Bool("dont-wait-for-slave-start", false, "won't wait for replication to start (useful when restoring from master server)") fetchConcurrency := subFlags.Int("fetch-concurrency", 3, "how many files to fetch simultaneously") fetchRetryCount := subFlags.Int("fetch-retry-count", 3, "how many times to retry a failed transfer") subFlags.Parse(args) if subFlags.NArg() != 1 { relog.Fatal("Command restore requires <snapshot manifest file>") } rs, err := mysqlctl.ReadSnapshotManifest(subFlags.Arg(0)) if err == nil { err = mysqld.RestoreFromSnapshot(rs, *fetchConcurrency, *fetchRetryCount, *dontWaitForSlaveStart, nil) } if err != nil { relog.Fatal("restore failed: %v", err) } }