// Apply populates the flag given the flag set and environment func (f IntSliceFlag) Apply(set *flag.FlagSet) { if f.EnvVars != nil { for _, envVar := range f.EnvVars { if envVal := os.Getenv(envVar); envVal != "" { newVal := NewIntSlice() for _, s := range strings.Split(envVal, ",") { s = strings.TrimSpace(s) err := newVal.Set(s) if err != nil { fmt.Fprintf(ErrWriter, err.Error()) } } f.Value = newVal break } } } if f.Value == nil { f.Value = NewIntSlice() } for _, name := range f.Names() { set.Var(f.Value, name, f.Usage) } }
func (a *app) parseArgs(fs *flag.FlagSet, args []string) error { fs.SetOutput(a.out) fs.Usage = func() { fmt.Fprintf(a.out, help, args[0], args[0]) fs.PrintDefaults() } fs.Var(&a.typeNames, "type", "A generated proto.Message type to generate stubs for (required, repeatable)") fs.StringVar(&a.outFile, "out", "proto_gae.gen.go", "The name of the output file") fs.StringVar(&a.header, "header", copyright, "Header text to put at the top of "+ "the generated file. Defaults to the Chromium Authors copyright.") if err := fs.Parse(args[1:]); err != nil { return err } fail := errors.MultiError(nil) if a.typeNames.Data == nil || a.typeNames.Data.Len() == 0 { fail = append(fail, errors.New("must specify one or more -type")) } if !strings.HasSuffix(a.outFile, ".go") { fail = append(fail, errors.New("-output must end with '.go'")) } if len(fail) > 0 { for _, e := range fail { fmt.Fprintln(a.out, "error:", e) } fmt.Fprintln(a.out) fs.Usage() return fail } return nil }
func (cmd *mark) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) f.Var(flags.NewOptionalBool(&cmd.ssd), "ssd", "Mark as SSD") f.Var(flags.NewOptionalBool(&cmd.local), "local", "Mark as local") }
func (cmd *create) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) modes := []string{ string(types.HostMountModeReadOnly), string(types.HostMountModeReadWrite), } f.StringVar(&cmd.Name, "name", "", "Datastore name") f.Var(&cmd.Type, "type", fmt.Sprintf("Datastore type (%s)", strings.Join(allTypes, "|"))) f.BoolVar(&cmd.Force, "force", false, "Ignore DuplicateName error if datastore is already mounted on a host") // Options for NAS f.StringVar(&cmd.RemoteHost, "remote-host", "", "Remote hostname of the NAS datastore") f.StringVar(&cmd.RemotePath, "remote-path", "", "Remote path of the NFS mount point") f.StringVar(&cmd.AccessMode, "mode", modes[0], fmt.Sprintf("Access mode for the mount point (%s)", strings.Join(modes, "|"))) f.StringVar(&cmd.UserName, "username", "", "Username to use when connecting (CIFS only)") f.StringVar(&cmd.Password, "password", "", "Password to use when connecting (CIFS only)") // Options for VMFS f.StringVar(&cmd.DiskCanonicalName, "disk", "", "Canonical name of disk (VMFS only)") // Options for Local f.StringVar(&cmd.Path, "path", "", "Local directory path for the datastore (local only)") }
func (cmd *add) DefineFlags(fs *flag.FlagSet) { fs.BoolVar(&cmd.json, "json", false, "Output result as JSON") fs.StringVar(&cmd.uri, "uri", "", "Drain URI (eg: udp://logs.loggly.com:12345)") fs.Var(&cmd.filters, "filter", "Message filter") cmd.params = make(map[string]string) fs.Var(&cmd.params, "o", "Drain options (eg: -o 'limit=100' or -o 'format={{.Text}}'") }
func (cmd *add) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) f.StringVar(&cmd.spec.VswitchName, "vswitch", "", "vSwitch Name") f.Var(flags.NewInt32(&cmd.spec.VlanId), "vlan", "VLAN ID") }
func (cmd *change) Register(f *flag.FlagSet) { f.Int64Var(&cmd.MemoryMB, "m", 0, "Size in MB of memory") f.IntVar(&cmd.NumCPUs, "c", 0, "Number of CPUs") f.StringVar(&cmd.GuestId, "g", "", "Guest OS") f.StringVar(&cmd.Name, "name", "", "Display name") f.Var(&cmd.extraConfig, "e", "ExtraConfig. <key>=<value>") }
func NewFlagOverwrite( set *flag.FlagSet, config *Config, name, path, def, usage string, ) *string { if config == nil { panic("Missing configuration") } if path == "" { panic("empty path") } if def != "" { err := config.SetString(path, -1, def) if err != nil { panic(err) } } f := &flagOverwrite{ config: config.access(), path: path, value: def, } if set == nil { flag.Var(f, name, usage) } else { set.Var(f, name, usage) } return &f.value }
// FlagByType sets the appropriate flag for its type. func FlagByType(fs *flag.FlagSet, structName string, fval reflect.Value, ftype reflect.StructField) { // Get a pointer; FlagSet needs a pointer to set the struct's field if fval.Kind() == reflect.Ptr { // Short-circuit log.Printf("Skipping field %s: %s", ftype.Name, ftype.Type.String()) return } //log.Printf("Getting pointer to %s", ftype.Name) fval = fval.Addr() flagName := NameToFlag(ftype.Name) flagHelp := fmt.Sprintf("%s:%s", structName, ftype.Name) log.Printf("Converting %s => %s", ftype.Name, flagName) //log.Printf("Switching on type %s...", ftype.Type.String()) switch fval := fval.Interface().(type) { case *int: fs.IntVar(fval, flagName, 0, flagHelp) case *float64: fs.Float64Var(fval, flagName, 0.0, flagHelp) case *string: fs.StringVar(fval, flagName, "", flagHelp) case *bool: fs.BoolVar(fval, flagName, false, flagHelp) case *time.Time: t := (*time.Time)(fval) // Get a *time.Time pointer to fval *t = time.Now() // Set a default of time.Now() fs.Var((*TimeFlag)(fval), flagName, flagHelp) default: log.Printf("unexpected type %s\n", ftype.Type.String()) } }
func (cmd *start) Register(ctx context.Context, f *flag.FlagSet) { cmd.GuestFlag, ctx = newGuestFlag(ctx) cmd.GuestFlag.Register(ctx, f) f.StringVar(&cmd.dir, "C", "", "The absolute path of the working directory for the program to start") f.Var(&cmd.vars, "e", "Set environment variable (key=val)") }
func influxdbCommandLine(cli *flag.FlagSet) CommandLineHandler { ix := &influx{ logger: NewLogger("[ostent sendto-influxdb] "), RefreshFlag: flags.Period{Duration: 10 * time.Second}, // 10s default // ServerAddr: flags.NewBind(8086), } cli.Var(&ix.RefreshFlag, "influxdb-refresh", "InfluxDB refresh interval") cli.StringVar(&ix.ServerAddr, "sendto-influxdb", "", "InfluxDB server address") cli.StringVar(&ix.Database, "influxdb-database", "ostent", "InfluxDB database") cli.StringVar(&ix.Username, "influxdb-username", "", "InfluxDB username") cli.StringVar(&ix.Password, "influxdb-password", "", "InfluxDB password") return func() (AtexitHandler, bool, error) { if ix.ServerAddr == "" { return nil, false, nil } ostent.AddBackground(func(defaultPeriod flags.Period) { /* if ix.RefreshFlag.Duration == 0 { // if .RefreshFlag had no default ix.RefreshFlag = defaultPeriod } */ go influxdb.Influxdb(ostent.Reg1s.Registry, ix.RefreshFlag.Duration, &influxdb.Config{ Host: ix.ServerAddr, //.String(), Database: ix.Database, Username: ix.Username, Password: ix.Password, }) }) return nil, false, nil } }
func (s *ResourceConfigSpecFlag) Register(f *flag.FlagSet) { opts := []struct { name string units string *types.ResourceAllocationInfo }{ {"CPU", "MHz", &s.CpuAllocation}, {"Memory", "MB", &s.MemoryAllocation}, } for _, opt := range opts { prefix := strings.ToLower(opt.name)[:3] shares := (*sharesInfo)(opt.Shares) expandableReservation := false if v := opt.ExpandableReservation; v != nil { expandableReservation = *v } // Initialize bool pointer opt.ExpandableReservation = types.NewBool(false) f.Int64Var(&opt.Limit, prefix+".limit", 0, opt.name+" limit in "+opt.units) f.Int64Var(&opt.Reservation, prefix+".reservation", 0, opt.name+" reservation in "+opt.units) f.BoolVar(opt.ExpandableReservation, prefix+".expandable", expandableReservation, opt.name+" expandable reservation") f.Var(shares, prefix+".shares", opt.name+" shares level or number") } }
func registerFlag(set *goflag.FlagSet, v goflag.Value, name, usage string) { if set != nil { set.Var(v, name, usage) } else { goflag.Var(v, name, usage) } }
func flRun(fl *flag.FlagSet) { flPodManifest(fl) SaveIDFlag(fl) fl.Var(&flAppName, "app", "Specify app to run for a multi-app pod") fl.BoolVar(&flDestroy, "destroy", false, "Destroy pod when done") fl.BoolVar(&flTerminal, "t", false, "Attach app to the terminal (single-app containers only)") }
// Flag configures the given FlagSet with the flags to configure // all active experiments. func Flag(fs *flag.FlagSet) { for _, id := range All { desc := id.Flag() key := fmt.Sprintf("X%s", id.Flag()) fs.Var(&idValue{X: id}, key, desc) } }
// Apply populates the flag given the flag set and environment func (f Int64SliceFlag) Apply(set *flag.FlagSet) { if f.EnvVar != "" { for _, envVar := range strings.Split(f.EnvVar, ",") { envVar = strings.TrimSpace(envVar) if envVal := os.Getenv(envVar); envVal != "" { newVal := &Int64Slice{} for _, s := range strings.Split(envVal, ",") { s = strings.TrimSpace(s) err := newVal.Set(s) if err != nil { fmt.Fprintf(ErrWriter, err.Error()) } } f.Value = newVal break } } } eachName(f.Name, func(name string) { if f.Value == nil { f.Value = &Int64Slice{} } set.Var(f.Value, name, f.Usage) }) }
func graphiteCommandLine(cli *flag.FlagSet) CommandLineHandler { gr := &graphite{ logger: NewLogger("[ostent sendto-graphite] "), RefreshFlag: flags.Period{Duration: 10 * time.Second}, // 10s default ServerAddr: flags.NewBind(2003), } cli.Var(&gr.RefreshFlag, "graphite-refresh", "Graphite refresh interval") cli.Var(&gr.ServerAddr, "sendto-graphite", "Graphite server address") return func() (AtexitHandler, bool, error) { if gr.ServerAddr.Host == "" { return nil, false, nil } ostent.AddBackground(func(defaultPeriod flags.Period) { /* if gr.RefreshFlag.Duration == 0 { // if .RefreshFlag had no default gr.RefreshFlag = defaultPeriod } */ gc := &carbond{ logger: gr.logger, serveraddr: gr.ServerAddr.String(), PeriodParam: params.NewPeriodParam(gr.RefreshFlag, "refreshgraphite", nil), } ostent.Register <- gc }) return nil, false, nil } }
func (r *run) ParamsParser(args []string) (interface{}, error) { var ( fs flag.FlagSet pkgMatch flagParam verMatch string ) if len(args) < 1 || args[0] == "" || args[0] == "help" { printHelp(true) return nil, nil } fs.Init("pkg", flag.ContinueOnError) fs.Var(&pkgMatch, "name", "see help") fs.StringVar(&verMatch, "version", "", "see help") err := fs.Parse(args) if err != nil { return nil, err } p := newParameters() p.PkgMatch.Matches = pkgMatch if verMatch != "" { p.VerMatch = verMatch } r.Parameters = *p return r.Parameters, r.ValidateParameters() }
func (flag *AuthFlag) Register(f *flag.FlagSet) { env := "GOVC_GUEST_LOGIN" value := os.Getenv(env) flag.Set(value) usage := fmt.Sprintf("Guest VM credentials [%s]", env) f.Var(flag, "l", usage) }
func (cmd *enter) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) f.Var(flags.NewInt32(&cmd.timeout), "timeout", "Timeout") f.BoolVar(&cmd.evacuate, "evacuate", false, "Evacuate powered off VMs") }
// ApplyWithError populates the flag given the flag set and environment func (f Int64SliceFlag) 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 { newVal := &Int64Slice{} for _, s := range strings.Split(envVal, ",") { s = strings.TrimSpace(s) if err := newVal.Set(s); err != nil { return fmt.Errorf("could not parse %s as int64 slice value for flag %s: %s", envVal, f.Name, err) } } f.Value = newVal break } } } eachName(f.Name, func(name string) { if f.Value == nil { f.Value = &Int64Slice{} } set.Var(f.Value, name, f.Usage) }) return nil }
func (flag *ClientFlag) Register(ctx context.Context, f *flag.FlagSet) { flag.RegisterOnce(func() { flag.DebugFlag.Register(ctx, f) { flag.Set(os.Getenv(envURL)) usage := fmt.Sprintf("%s [%s]", cDescr, envURL) f.Var(flag, "u", usage) } { flag.username = os.Getenv(envUsername) flag.password = os.Getenv(envPassword) } { value := os.Getenv(envCertificate) usage := fmt.Sprintf("Certificate [%s]", envCertificate) f.StringVar(&flag.cert, "cert", value, usage) } { value := os.Getenv(envPrivateKey) usage := fmt.Sprintf("Private key [%s]", envPrivateKey) f.StringVar(&flag.key, "key", value, usage) } { insecure := false switch env := strings.ToLower(os.Getenv(envInsecure)); env { case "1", "true": insecure = true } usage := fmt.Sprintf("Skip verification of server certificate [%s]", envInsecure) f.BoolVar(&flag.insecure, "k", insecure, usage) } { persist := true switch env := strings.ToLower(os.Getenv(envPersist)); env { case "0", "false": persist = false } usage := fmt.Sprintf("Persist session to disk [%s]", envPersist) f.BoolVar(&flag.persist, "persist-session", persist, usage) } { env := os.Getenv(envMinAPIVersion) if env == "" { env = "5.5" } flag.minAPIVersion = env } }) }
func (cmd *logs) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) cmd.Max = 25 // default f.Var(flags.NewInt32(&cmd.Max), "n", "Output the last N logs") f.StringVar(&cmd.Key, "log", "", "Log file key") }
func (cmd *change) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) f.Var((*serverConfig)(&cmd.HostNtpConfig), "server", "IP or FQDN for NTP server(s)") f.StringVar(&cmd.TimeZone, "tz", "", "Change timezone of the host") f.StringVar(&cmd.date, "date", "", "Update the date/time on the host") }
func registerCliFlagsWithPassgoRegistrar(passgo *app.App, flagSet *flag.FlagSet) { passgo.Register("passgoFlags", PassgoFlags) flagsToParse := passgo.Lookup("passgoFlags").([]PassgoFlag) for _, flag := range flagsToParse { flagSet.Var(flag, flag.Name(), flag.Usage()) passgo.Register(flag.Name(), flag) } }
// RegisterReaderFlags registers the 'reader' flags (see below) // with the parent command. The values of the flags can be accessed via // the supplied ReaderFlagValues struct. // The reader flags are: // --skip-profiles // --profiles-db // --profiles // --merge-policies // --target and --env func RegisterReaderFlags(flags *flag.FlagSet, fv *ReaderFlagValues, defaultProfiles, defaultDBPath string) { flags.Var(&fv.ProfilesMode, "skip-profiles", "if set, no profiles will be used") RegisterDBPathFlag(flags, &fv.DBFilename, defaultDBPath) RegisterProfilesFlag(flags, defaultProfiles, &fv.Profiles) fv.MergePolicies = profilesreader.JiriMergePolicies() RegisterMergePoliciesFlag(flags, &fv.MergePolicies) profiles.RegisterTargetAndEnvFlags(flags, &fv.Target) }
func (cmd *configure) Register(f *flag.FlagSet) { f.Var(flags.NewOptionalBool(&cmd.Enabled), "enabled", "") f.IntVar(&cmd.StartDelay, "start-delay", 0, "") f.StringVar(&cmd.StopAction, "stop-action", "", "") f.IntVar(&cmd.StopDelay, "stop-delay", 0, "") f.Var(flags.NewOptionalBool(&cmd.WaitForHeartbeat), "wait-for-heartbeat", "") }
func (cmd *info) Register(f *flag.FlagSet) { err := cmd.typ.Set("lun") if err != nil { panic(err) } f.Var(&cmd.typ, "t", fmt.Sprintf("Type (%s)", strings.Join(infoTypes, ","))) }
func (cmd *add) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) cmd.spec.NumPorts = 128 // default f.Var(flags.NewInt32(&cmd.spec.NumPorts), "ports", "Number of ports") f.Var(flags.NewInt32(&cmd.spec.Mtu), "mtu", "MTU") f.StringVar(&cmd.nic, "nic", "", "Bridge nic device") }
func (cmd *vnc) Register(f *flag.FlagSet) { cmd.SearchFlag = flags.NewSearchFlag(flags.SearchVirtualMachines) f.BoolVar(&cmd.Enable, "enable", false, "Enable VNC") f.BoolVar(&cmd.Disable, "disable", false, "Disable VNC") f.IntVar(&cmd.Port, "port", -1, "VNC port (-1 for auto-select)") f.Var(&cmd.PortRange, "port-range", "VNC port auto-select range") f.StringVar(&cmd.Password, "password", "", "VNC password") }