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)
}
}
// ApplyWithError populates the flag given the flag set and environment
func (f Uint64Flag) 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.ParseUint(envVal, 0, 64)
if err != nil {
return fmt.Errorf("could not parse %s as uint64 value for flag %s: %s", envVal, f.Name, err)
}
f.Value = uint64(envValInt)
break
}
}
}
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.Uint64Var(f.Destination, name, f.Value, f.Usage)
return
}
set.Uint64(name, f.Value, f.Usage)
})
return nil
}
func parseFlagArg(fv reflect.Value, f *flag.FlagSet, tag string) (err error) {
n := 0
for n < len(tag) {
if tag[n] == ',' || tag[n] == ' ' {
break
}
n++
}
name := tag[:n]
usage := ""
pos := strings.Index(tag[n:], " - ")
if pos >= 0 {
usage = tag[pos+3:]
}
switch fv.Kind() {
case reflect.Ptr:
switch fv.Elem().Kind() {
case reflect.Bool:
fv.Set(reflect.ValueOf(f.Bool(name, false, usage)))
case reflect.Int:
fv.Set(reflect.ValueOf(f.Int(name, 0, usage)))
case reflect.Uint:
fv.Set(reflect.ValueOf(f.Uint(name, 0, usage)))
case reflect.Uint64:
fv.Set(reflect.ValueOf(f.Uint64(name, 0, usage)))
default:
return ErrUnsupportedFlagType
}
case reflect.Bool:
f.BoolVar(fv.Addr().Interface().(*bool), name, false, usage)
case reflect.Int:
f.IntVar(fv.Addr().Interface().(*int), name, 0, usage)
case reflect.Uint:
f.UintVar(fv.Addr().Interface().(*uint), name, 0, usage)
case reflect.Uint64:
f.Uint64Var(fv.Addr().Interface().(*uint64), name, 0, usage)
default:
return ErrUnsupportedFlagType
}
return nil
}
// Apply populates the flag given the flag set and environment
func (f Uint64Flag) Apply(set *flag.FlagSet) {
if f.EnvVar != "" {
for _, envVar := range strings.Split(f.EnvVar, ",") {
envVar = strings.TrimSpace(envVar)
if envVal := os.Getenv(envVar); envVal != "" {
envValInt, err := strconv.ParseUint(envVal, 0, 64)
if err == nil {
f.Value = uint64(envValInt)
break
}
}
}
}
eachName(f.Name, func(name string) {
if f.Destination != nil {
set.Uint64Var(f.Destination, name, f.Value, f.Usage)
return
}
set.Uint64(name, f.Value, f.Usage)
})
}
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 regexp for tables")
excludeTablesString := subFlags.String("exclude_tables", "", "do not dump this comma separated list of regexp for 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")
keyType := subFlags.String("key_type", "uint64", "type of the key column")
subFlags.Parse(args)
if subFlags.NArg() != 2 {
log.Fatalf("action multisnapshot requires <db name> <key name>")
}
shards, err := key.ParseShardingSpec(*spec)
if err != nil {
log.Fatalf("multisnapshot failed: %v", err)
}
var tables []string
if *tablesString != "" {
tables = strings.Split(*tablesString, ",")
}
var excludedTables []string
if *excludeTablesString != "" {
excludedTables = strings.Split(*excludeTablesString, ",")
}
kit := key.KeyspaceIdType(*keyType)
if !key.IsKeyspaceIdTypeInList(kit, key.AllKeyspaceIdTypes) {
log.Fatalf("invalid key_type")
}
filenames, err := mysqld.CreateMultiSnapshot(shards, subFlags.Arg(0), subFlags.Arg(1), kit, tabletAddr, false, *concurrency, tables, excludedTables, *skipSlaveRestart, *maximumFilesize, nil)
if err != nil {
log.Fatalf("multisnapshot failed: %v", err)
} else {
log.Infof("manifest locations: %v", filenames)
}
}