// 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")
}