[do not merge] Slack vitess v10.0.2.vtctld

go/cmd/vtadmin/main.go

@@ -81,6 +81,10 @@ func main() {
  rootCmd.Flags().Var(&clusterFileConfig, "cluster-config", "path to a yaml cluster configuration. see clusters.example.yaml") // (TODO:@amason) provide example config.
  rootCmd.Flags().Var(&defaultClusterConfig, "cluster-defaults", "default options for all clusters")
 
+ rootCmd.Flags().AddGoFlag(flag.Lookup("tracer")) // defined in go/vt/trace
+ rootCmd.Flags().AddGoFlag(flag.Lookup("tracing-enable-logging")) // defined in go/vt/trace
+ rootCmd.Flags().AddGoFlag(flag.Lookup("tracing-sampling-type")) // defined in go/vt/trace
+ rootCmd.Flags().AddGoFlag(flag.Lookup("tracing-sampling-rate")) // defined in go/vt/trace
  rootCmd.Flags().BoolVar(&opts.EnableTracing, "grpc-tracing", false, "whether to enable tracing on the gRPC server")
  rootCmd.Flags().BoolVar(&httpOpts.EnableTracing, "http-tracing", false, "whether to enable tracing on the HTTP server")
  rootCmd.Flags().BoolVar(&httpOpts.DisableCompression, "http-no-compress", false, "whether to disable compression of HTTP API responses")

go/cmd/vtctlclient/main.go

@@ -67,6 +67,10 @@ func main() {
  logutil.LogEvent(logger, e)
  })
  if err != nil {
+ if strings.Contains(err.Error(), "flag: help requested") {
+ return
+ }
+
  errStr := strings.Replace(err.Error(), "remote error: ", "", -1)
  fmt.Printf("%s Error: %s\n", flag.Arg(0), errStr)
  log.Error(err)

go/cmd/vtctldclient/internal/command/backups.go

@@ -23,30 +23,54 @@ import (
  "github.com/spf13/cobra"
 
  "vitess.io/vitess/go/cmd/vtctldclient/cli"
+ "vitess.io/vitess/go/vt/topo/topoproto"
+
  vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata"
 )
 
 // GetBackups makes a GetBackups gRPC call to a vtctld.
 var GetBackups = &cobra.Command{
- Use: "GetBackups keyspace shard",
- Args: cobra.ExactArgs(2),
+ Use: "GetBackups <keyspace/shard>",
+ Args: cobra.ExactArgs(1),
  RunE: commandGetBackups,
 }
 
+var getBackupsOptions = struct {
+ Limit uint32
+ Detailed bool
+ DetailedLimit uint32
+ OutputJSON bool
+}{}
+
 func commandGetBackups(cmd *cobra.Command, args []string) error {
- cli.FinishedParsing(cmd)
+ keyspace, shard, err := topoproto.ParseKeyspaceShard(cmd.Flags().Arg(0))
+ if err != nil {
+ return err
+ }
 
- keyspace := cmd.Flags().Arg(0)
- shard := cmd.Flags().Arg(1)
+ cli.FinishedParsing(cmd)
 
  resp, err := client.GetBackups(commandCtx, &vtctldatapb.GetBackupsRequest{
- Keyspace: keyspace,
- Shard: shard,
+ Keyspace: keyspace,
+ Shard: shard,
+ Limit: getBackupsOptions.Limit,
+ Detailed: getBackupsOptions.Detailed,
+ DetailedLimit: getBackupsOptions.DetailedLimit,
  })
  if err != nil {
  return err
  }
 
+ if getBackupsOptions.OutputJSON || getBackupsOptions.Detailed {
+ data, err := cli.MarshalJSON(resp)
+ if err != nil {
+ return err
+ }
+
+ fmt.Printf("%s\n", data)
+ return nil
+ }
+
  names := make([]string, len(resp.Backups))
  for i, b := range resp.Backups {
  names[i] = b.Name
@@ -58,5 +82,9 @@ func commandGetBackups(cmd *cobra.Command, args []string) error {
 }
 
 func init() {
+ GetBackups.Flags().Uint32VarP(&getBackupsOptions.Limit, "limit", "l", 0, "Retrieve only the most recent N backups")
+ GetBackups.Flags().BoolVarP(&getBackupsOptions.OutputJSON, "json", "j", false, "Output backup info in JSON format rather than a list of backups")
+ GetBackups.Flags().BoolVar(&getBackupsOptions.Detailed, "detailed", false, "Get detailed backup info, such as the engine used for each backup, and its status. Implies --json.")
+ GetBackups.Flags().Uint32Var(&getBackupsOptions.DetailedLimit, "detailed-limit", 0, "Get detailed backup info for only the most recent N backups. Ignored if --detailed is not passed.")
  Root.AddCommand(GetBackups)
 }

go/cmd/vtctldclient/internal/command/cells.go

@@ -24,10 +24,55 @@ import (
 
  "vitess.io/vitess/go/cmd/vtctldclient/cli"
 
+ topodatapb "vitess.io/vitess/go/vt/proto/topodata"
  vtctldatapb "vitess.io/vitess/go/vt/proto/vtctldata"
 )
 
 var (
+ // AddCellInfo makes an AddCellInfo gRPC call to a vtctld.
+ AddCellInfo = &cobra.Command{
+ Use: "AddCellInfo --root <root> [--server-address <addr>] <cell>",
+ Short: "Registers a local topology service in a new cell by creating the CellInfo.",
+ Long: `Registers a local topology service in a new cell by creating the CellInfo
+with the provided parameters.
+
+The address will be used to connect to the topology service, and Vitess data will
+be stored starting at the provided root.`,
+ DisableFlagsInUseLine: true,
+ Args: cobra.ExactArgs(1),
+ RunE: commandAddCellInfo,
+ }
+ // AddCellsAlias makes an AddCellsAlias gRPC call to a vtctld.
+ AddCellsAlias = &cobra.Command{
+ Use: "AddCellsAlias --cells <cell1,cell2,...> [--cells <cell3> ...] <alias>",
+ Short: "Defines a group of cells that can be referenced by a single name (the alias).",
+ Long: `Defines a group of cells that can be referenced by a single name (the alias).
+
+When routing query traffic, replica/rdonly traffic can be routed across cells
+within the group (alias). Only primary traffic can be routed across cells not in
+the same group (alias).`,
+ DisableFlagsInUseLine: true,
+ Args: cobra.ExactArgs(1),
+ RunE: commandAddCellsAlias,
+ }
+ // DeleteCellInfo makes a DeleteCellInfo gRPC call to a vtctld.
+ DeleteCellInfo = &cobra.Command{
+ Use: "DeleteCellInfo [--force] <cell>",
+ Short: "Deletes the CellInfo for the provided cell.",
+ Long: "Deletes the CellInfo for the provided cell. The cell cannot be referenced by any Shard record.",
+ DisableFlagsInUseLine: true,
+ Args: cobra.ExactArgs(1),
+ RunE: commandDeleteCellInfo,
+ }
+ // DeleteCellsAlias makes a DeleteCellsAlias gRPC call to a vtctld.
+ DeleteCellsAlias = &cobra.Command{
+ Use: "DeleteCellsAlias <alias>",
+ Short: "Deletes the CellsAlias for the provided alias.",
+ Long: "Deletes the CellsAlias for the provided alias.",
+ DisableFlagsInUseLine: true,
+ Args: cobra.ExactArgs(1),
+ RunE: commandDeleteCellsAlias,
+ }
  // GetCellInfoNames makes a GetCellInfoNames gRPC call to a vtctld.
  GetCellInfoNames = &cobra.Command{
  Use: "GetCellInfoNames",
@@ -46,8 +91,99 @@ var (
  Args: cobra.NoArgs,
  RunE: commandGetCellsAliases,
  }
+ // UpdateCellInfo makes an UpdateCellInfo gRPC call to a vtctld.
+ UpdateCellInfo = &cobra.Command{
+ Use: "UpdateCellInfo [--root <root>] [--server-address <addr>] <cell>",
+ Short: "Updates the content of a CellInfo with the provided parameters, creating the CellInfo if it does not exist.",
+ Long: `Updates the content of a CellInfo with the provided parameters, creating the CellInfo if it does not exist.
+
+If a value is empty, it is ignored.`,
+ DisableFlagsInUseLine: true,
+ Args: cobra.ExactArgs(1),
+ RunE: commandUpdateCellInfo,
+ }
+ // UpdateCellsAlias makes an UpdateCellsAlias gRPC call to a vtctld.
+ UpdateCellsAlias = &cobra.Command{
+ Use: "UpdateCellsAlias [--cells <cell1,cell2,...> [--cells <cell4> ...]] <alias>",
+ Short: "Updates the content of a CellsAlias with the provided parameters, creating the CellsAlias if it does not exist.",
+ Long: "Updates the content of a CellsAlias with the provided parameters, creating the CellsAlias if it does not exist.",
+ DisableFlagsInUseLine: true,
+ Args: cobra.ExactArgs(1),
+ RunE: commandUpdateCellsAlias,
+ }
 )
 
+var addCellInfoOptions topodatapb.CellInfo
+
+func commandAddCellInfo(cmd *cobra.Command, args []string) error {
+ cli.FinishedParsing(cmd)
+
+ cell := cmd.Flags().Arg(0)
+ _, err := client.AddCellInfo(commandCtx, &vtctldatapb.AddCellInfoRequest{
+ Name: cell,
+ CellInfo: &addCellInfoOptions,
+ })
+ if err != nil {
+ return err
+ }
+
+ fmt.Printf("Created cell: %s\n", cell)
+ return nil
+}
+
+var addCellsAliasOptions topodatapb.CellsAlias
+
+func commandAddCellsAlias(cmd *cobra.Command, args []string) error {
+ cli.FinishedParsing(cmd)
+
+ alias := cmd.Flags().Arg(0)
+ _, err := client.AddCellsAlias(commandCtx, &vtctldatapb.AddCellsAliasRequest{
+ Name: alias,
+ Cells: addCellsAliasOptions.Cells,
+ })
+ if err != nil {
+ return err
+ }
+
+ fmt.Printf("Created cells alias: %s (cells = %v)\n", alias, addCellsAliasOptions.Cells)
+ return nil
+}
+
+var deleteCellInfoOptions = struct {
+ Force bool
+}{}
+
+func commandDeleteCellInfo(cmd *cobra.Command, args []string) error {
+ cli.FinishedParsing(cmd)
+
+ cell := cmd.Flags().Arg(0)
+ _, err := client.DeleteCellInfo(commandCtx, &vtctldatapb.DeleteCellInfoRequest{
+ Name: cell,
+ Force: deleteCellInfoOptions.Force,
+ })
+ if err != nil {
+ return err
+ }
+
+ fmt.Printf("Deleted cell %s\n", cell)
+ return nil
+}
+
+func commandDeleteCellsAlias(cmd *cobra.Command, args []string) error {
+ cli.FinishedParsing(cmd)
+
+ alias := cmd.Flags().Arg(0)
+ _, err := client.DeleteCellsAlias(commandCtx, &vtctldatapb.DeleteCellsAliasRequest{
+ Name: alias,
+ })
+ if err != nil {
+ return err
+ }
+
+ fmt.Printf("Delete cells alias %s\n", alias)
+ return nil
+}
+
 func commandGetCellInfoNames(cmd *cobra.Command, args []string) error {
  cli.FinishedParsing(cmd)
 
@@ -99,8 +235,73 @@ func commandGetCellsAliases(cmd *cobra.Command, args []string) error {
  return nil
 }
 
+var updateCellInfoOptions topodatapb.CellInfo
+
+func commandUpdateCellInfo(cmd *cobra.Command, args []string) error {
+ cli.FinishedParsing(cmd)
+
+ cell := cmd.Flags().Arg(0)
+ resp, err := client.UpdateCellInfo(commandCtx, &vtctldatapb.UpdateCellInfoRequest{
+ Name: cell,
+ CellInfo: &updateCellInfoOptions,
+ })
+ if err != nil {
+ return err
+ }
+
+ data, err := cli.MarshalJSON(resp.CellInfo)
+ if err != nil {
+ return err
+ }
+
+ fmt.Printf("Updated cell %s. New CellInfo:\n%s\n", resp.Name, data)
+ return nil
+}
+
+var updateCellsAliasOptions topodatapb.CellsAlias
+
+func commandUpdateCellsAlias(cmd *cobra.Command, args []string) error {
+ cli.FinishedParsing(cmd)
+
+ alias := cmd.Flags().Arg(0)
+ resp, err := client.UpdateCellsAlias(commandCtx, &vtctldatapb.UpdateCellsAliasRequest{
+ Name: alias,
+ CellsAlias: &updateCellsAliasOptions,
+ })
+ if err != nil {
+ return err
+ }
+
+ data, err := cli.MarshalJSON(resp.CellsAlias)
+ if err != nil {
+ return err
+ }
+
+ fmt.Printf("Updated cells alias %s. New CellsAlias:\n%s\n", resp.Name, data)
+ return nil
+}
+
 func init() {
+ AddCellInfo.Flags().StringVarP(&addCellInfoOptions.ServerAddress, "server-address", "a", "", "The address the topology server will connect to for this cell.")
+ AddCellInfo.Flags().StringVarP(&addCellInfoOptions.Root, "root", "r", "", "The root path the topology server will use for this cell")
+ AddCellInfo.MarkFlagRequired("root")
+ Root.AddCommand(AddCellInfo)
+
+ AddCellsAlias.Flags().StringSliceVarP(&addCellsAliasOptions.Cells, "cells", "c", nil, "The list of cell names that are members of this alias.")
+ Root.AddCommand(AddCellsAlias)
+
+ DeleteCellInfo.Flags().BoolVarP(&deleteCellInfoOptions.Force, "force", "f", false, "Proceeds even if the cell's topology server cannot be reached. The assumption is that you shut down the entire cell, and just need to update the global topo data.")
+ Root.AddCommand(DeleteCellInfo)
+ Root.AddCommand(DeleteCellsAlias)
+
  Root.AddCommand(GetCellInfoNames)
  Root.AddCommand(GetCellInfo)
  Root.AddCommand(GetCellsAliases)
+
+ UpdateCellInfo.Flags().StringVarP(&updateCellInfoOptions.ServerAddress, "server-address", "a", "", "The address the topology server will connect to for this cell.")
+ UpdateCellInfo.Flags().StringVarP(&updateCellInfoOptions.Root, "root", "r", "", "The root path the topology server will use for this cell")
+ Root.AddCommand(UpdateCellInfo)
+
+ UpdateCellsAlias.Flags().StringSliceVarP(&updateCellsAliasOptions.Cells, "cells", "c", nil, "The list of cell names that are members of this alias.")
+ Root.AddCommand(UpdateCellsAlias)
 }