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.IntVar(&cmd.spec.VlanId, "vlan", 0, "VLAN ID") }
func (cmd *ls) Register(ctx context.Context, f *flag.FlagSet) { cmd.DatacenterFlag, ctx = flags.NewDatacenterFlag(ctx) cmd.DatacenterFlag.Register(ctx, f) f.BoolVar(&cmd.Long, "l", false, "Long listing format") f.StringVar(&cmd.Type, "t", "", "Object type") }
// AddFlags adds flags for sous rectify. func (sr *SousRectify) AddFlags(fs *flag.FlagSet) { MustAddFlags(fs, &sr.SourceFlags, RectifyFilterFlagsHelp) fs.StringVar(&sr.flags.dryrun, "dry-run", "none", "prevent rectify from actually changing things - "+ "values are none,scheduler,registry,both") }
func (cmd *add) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) f.StringVar(&cmd.path, "dvs", "", "DVS path") f.StringVar(&cmd.pnic, "pnic", "vmnic0", "Name of the host physical NIC") }
func (cmd *change) Register(ctx context.Context, f *flag.FlagSet) { cmd.DatacenterFlag, ctx = flags.NewDatacenterFlag(ctx) cmd.DatacenterFlag.Register(ctx, f) cmd.DrsConfig = new(types.ClusterDrsConfigInfo) cmd.DasConfig = new(types.ClusterDasConfigInfo) cmd.VsanConfig = new(types.VsanClusterConfigInfo) cmd.VsanConfig.DefaultConfig = new(types.VsanClusterConfigInfoHostDefaultInfo) // DRS f.Var(flags.NewOptionalBool(&cmd.DrsConfig.Enabled), "drs-enabled", "Enable DRS") drsModes := []string{ string(types.DrsBehaviorManual), string(types.DrsBehaviorPartiallyAutomated), string(types.DrsBehaviorFullyAutomated), } f.StringVar((*string)(&cmd.DrsConfig.DefaultVmBehavior), "drs-mode", "", "DRS behavior for virtual machines: "+strings.Join(drsModes, ", ")) // HA f.Var(flags.NewOptionalBool(&cmd.DasConfig.Enabled), "ha-enabled", "Enable HA") // vSAN f.Var(flags.NewOptionalBool(&cmd.VsanConfig.Enabled), "vsan-enabled", "Enable vSAN") f.Var(flags.NewOptionalBool(&cmd.VsanConfig.DefaultConfig.AutoClaimStorage), "vsan-autoclaim", "") }
func policyRuleAddUpdateInitOptions(flagSet *flag.FlagSet) { flagSet.StringVar(&policyRuleOpts.policy, "policy", "", "Policy name or uuid") flagSet.StringVar(&policyRuleOpts.srcIpAddress, "source-address", "", "Source IP address prefix") flagSet.StringVar(&policyRuleOpts.dstIpAddress, "destination-address", "", "Destination IP address prefix") flagSet.StringVar(&policyRuleOpts.srcNetwork, "source-network", "", "Virtual-network name for source IP address") flagSet.StringVar(&policyRuleOpts.dstNetwork, "destination-network", "", "Virtual-network name for destination IP address") var allowedProtocolValues []string for key, _ := range protocolValues { allowedProtocolValues = append(allowedProtocolValues, key) } flagSet.Var(&policyRuleOpts.protocol, "protocol", fmt.Sprintf("IP protocol (one of [%s])", strings.Join(allowedProtocolValues, ","))) flagSet.Var(&policyRuleOpts.srcPort, "source-port", "Transport protocol (e.g. tcp, udp) source port") flagSet.Var(&policyRuleOpts.dstPort, "destination-port", "Transport protocol (e.g. tcp, udp) destination port") flagSet.BoolVar(&policyRuleOpts.actionDrop, "drop", false, "Discard packets") flagSet.BoolVar(&policyRuleOpts.actionDrop, "pass", false, "Accept packets (default)") }
func (cmd *remove) Register(ctx context.Context, f *flag.FlagSet) { cmd.PermissionFlag, ctx = NewPermissionFlag(ctx) cmd.PermissionFlag.Register(ctx, f) f.StringVar(&cmd.Principal, "principal", "", "User or group for which the permission is defined") f.BoolVar(&cmd.Group, "group", false, "True, if principal refers to a group name; false, for a user name") }
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 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 flagPointer(incoming reflect.Value, data *flag.FlagSet) error { if incoming.Type().Kind() == reflect.Ptr { return flagPointer(incoming.Elem(), data) } for i := 0; i < incoming.NumField(); i++ { field := incoming.Field(i) fieldType := incoming.Type().Field(i) if it := fieldType.Tag.Get("flag"); it != "" { /* Register the flag */ switch field.Type().Kind() { case reflect.Int: data.IntVar( (*int)(unsafe.Pointer(field.Addr().Pointer())), it, int(field.Int()), fieldType.Tag.Get("description"), ) continue case reflect.String: data.StringVar( (*string)(unsafe.Pointer(field.Addr().Pointer())), it, field.String(), fieldType.Tag.Get("description"), ) continue default: return fmt.Errorf("Unknown type: %s", field.Type().Kind()) } } } return nil }
func getCmd(flagset *flag.FlagSet) { flagset.Usage = func() { fmt.Fprintf(os.Stderr, "usage: %s get [args...] key\n", os.Args[0]) flagset.PrintDefaults() } flagset.StringVar(&secretKeyring, "secret-keyring", DefaultConfig.SecretKeyring, "path to armored secret keyring") flagset.Parse(os.Args[2:]) key := flagset.Arg(0) if key == "" { flagset.Usage() os.Exit(1) } backendStore, err := getBackendStore(backendName, endpoint) if err != nil { log.Fatal(err) } log.Printf("Looking at consul node %q\n", nodeKey(key)) if plaintext { value, err := getPlain(nodeKey(key), backendStore) if err != nil { log.Fatal(err) } fmt.Printf("%s\n", value) return } value, err := getEncrypted(nodeKey(key), secretKeyring, backendStore) if err != nil { log.Fatal(err) } fmt.Printf("%s\n", value) }
func (cmd *create) Register(f *flag.FlagSet) { cmd.configSpec = new(types.VMwareDVSConfigSpec) cmd.DVSCreateSpec.ConfigSpec = cmd.configSpec f.StringVar(&cmd.parent, "parent", "", "Path to parent folder for the new dvs") }
func listCmd(flagset *flag.FlagSet) { flagset.Usage = func() { fmt.Fprintf(os.Stderr, "usage: %s list [args...] key\n", os.Args[0]) flagset.PrintDefaults() } flagset.StringVar(&secretKeyring, "secret-keyring", ".secring.gpg", "path to armored secret keyring") flagset.Parse(os.Args[2:]) key := flagset.Arg(0) if key == "" { flagset.Usage() os.Exit(1) } backendStore, err := getBackendStore(backendName, endpoint) if err != nil { log.Fatal(err) } if plaintext { list, err := listPlain(key, backendStore) if err != nil { log.Fatal(err) } for _, kv := range list { fmt.Printf("%s: %s", kv.Key, kv.Value) } return } list, err := listEncrypted(key, secretKeyring, backendStore) if err != nil { log.Fatal(err) } for _, kv := range list { fmt.Printf("%s: %s", kv.Key, kv.Value) } }
func FlagsForClient(ccfg *ClientConfig, flagset *flag.FlagSet) { flagset.DurationVar(&ccfg.IdleTimeout, "timeout", DefaultIdleTimeout, "amount of idle time before timeout") flagset.IntVar(&ccfg.IdleConnectionsToInstance, "maxidle", DefaultIdleConnectionsToInstance, "maximum number of idle connections to a particular instance") flagset.IntVar(&ccfg.MaxConnectionsToInstance, "maxconns", DefaultMaxConnectionsToInstance, "maximum number of concurrent connections to a particular instance") flagset.StringVar(&ccfg.Region, "region", GetDefaultEnvVar("SKYNET_REGION", DefaultRegion), "region client is located in") flagset.StringVar(&ccfg.Host, "host", GetDefaultEnvVar("SKYNET_HOST", DefaultRegion), "host client is located in") }
func (cmd *TeamInit) RegisterFlags(f *flag.FlagSet) { f.StringVar(&cmd.Provider, "p", "vagrant", "Team provider name.") f.StringVar(&cmd.KlientID, "klient", "", "ID of the klient kite.") f.StringVar(&cmd.Team, "team", "koding", "Team name. If empty will get autogenerated.") f.StringVar(&cmd.StackTemplate, "stack", "-", "Stack template content.") f.StringVar(&cmd.Username, "u", defaultUsername, "Username for the kloud request.") }
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 addTestFlags(fs *flag.FlagSet) { addBuildFlags(fs) fs.BoolVar(&testCover, "cover", false, "enable coverage analysis") fs.StringVar(&testCoverMode, "covermode", "set", "Set covermode: set (default), count, atomic") fs.StringVar(&testCoverPkg, "coverpkg", "", "enable coverage analysis") fs.BoolVar(&testVerbose, "v", false, "enable verbose output of subcommands") }
// 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 (flag *SearchFlag) Register(ctx context.Context, fs *flag.FlagSet) { flag.RegisterOnce(func() { flag.ClientFlag.Register(ctx, fs) flag.DatacenterFlag.Register(ctx, fs) register := func(v *string, f string, d string) { f = fmt.Sprintf("%s.%s", strings.ToLower(flag.entity), f) d = fmt.Sprintf(d, flag.entity) fs.StringVar(v, f, "", d) } switch flag.t { case SearchVirtualMachines: register(&flag.byDatastorePath, "path", "Find %s by path to .vmx file") } switch flag.t { case SearchVirtualMachines, SearchHosts: register(&flag.byDNSName, "dns", "Find %s by FQDN") register(&flag.byIP, "ip", "Find %s by IP address") register(&flag.byUUID, "uuid", "Find %s by instance UUID") } register(&flag.byInventoryPath, "ipath", "Find %s by inventory path") }) }
func (cmd *instanceDelete) RegisterFlags(f *flag.FlagSet) { f.StringVar(&cmd.list.hostname, "hostname", "", "Filters instances by hostname.") f.StringVar(&cmd.list.env, "env", "", "Filters instances by environment.") f.IntVar(&cmd.list.id, "id", 0, "Filters instances by id.") f.BoolVar(&cmd.dry, "dry-run", false, "Dry run.") cmd.list.entries = true }
// ParamsParser implements a command line parameter parser for the ping module func (r *run) ParamsParser(args []string) (interface{}, error) { var ( err error pa params d, p string dp, c, t float64 fs flag.FlagSet ) if len(args) < 1 || args[0] == "" || args[0] == "help" { printHelp(true) return nil, fmt.Errorf("help printed") } fs.Init("ping", flag.ContinueOnError) fs.StringVar(&d, "d", "www.google.com", "see help") fs.Float64Var(&dp, "dp", -1, "see help") fs.StringVar(&p, "p", "icmp", "see help") fs.Float64Var(&c, "c", 3, "see help") fs.Float64Var(&t, "t", 5, "see help") err = fs.Parse(args) if err != nil { return nil, err } pa.Destination = d pa.DestinationPort = dp pa.Protocol = p pa.Count = c pa.Timeout = t r.Parameters = pa return pa, r.ValidateParameters() }
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 (r *run) ParamsParser(args []string) (interface{}, error) { var ( err error drift string fs flag.FlagSet ) if len(args) >= 1 && args[0] == "help" { printHelp(true) return nil, fmt.Errorf("help printed") } if len(args) == 0 { return r.Parameters, nil } fs.Init("time", flag.ContinueOnError) fs.StringVar(&drift, "drift", "", "see help") err = fs.Parse(args) if err != nil { return nil, err } _, err = time.ParseDuration(drift) if err != nil { return nil, fmt.Errorf("invalid drift duration. try help.") } r.Parameters.Drift = drift return r.Parameters, r.ValidateParameters() }
func (cmd *setcert) Register(ctx context.Context, f *flag.FlagSet) { cmd.ClientFlag, ctx = flags.NewClientFlag(ctx) cmd.ClientFlag.Register(ctx, f) f.StringVar(&cmd.cert, "cert-pem", "-", "PEM encoded certificate") f.StringVar(&cmd.org, "org", "VMware", "Organization for generated certificate") }
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 (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 (cmd *connect) Register(ctx context.Context, f *flag.FlagSet) { cmd.VirtualMachineFlag, ctx = flags.NewVirtualMachineFlag(ctx) cmd.VirtualMachineFlag.Register(ctx, f) f.StringVar(&cmd.device, "device", "", "serial port device name") f.BoolVar(&cmd.client, "client", false, "Use client direction") }
func (cmd *logs) Register(ctx context.Context, f *flag.FlagSet) { cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx) cmd.HostSystemFlag.Register(ctx, f) f.IntVar(&cmd.Max, "n", 25, "Output the last N logs") f.StringVar(&cmd.Key, "log", "", "Log file key") }
func (cmd *add) Register(f *flag.FlagSet) { f.StringVar(&cmd.cluster, "cluster", "*", "Path to cluster") f.StringVar(&cmd.license, "license", "", "Assign license key") f.BoolVar(&cmd.connect, "connect", true, "Immediately connect to host") }
func (c *config) addflags(s *flag.FlagSet) { repo := s.String("repo", "", "path to metadata.json") c.repo = repo version := s.String("version", "", "version to add (SemVer)") c.version = version status := s.String("status", "", "status of the version") c.status = status description := s.String("description", "", "description of the version (markdown)") s.StringVar(description, "desc", "", "Shortcut for --description") c.description = description provider := s.String("provider", "", "provider the box supports") c.provider = provider box := s.String("box", "", "url of the box") c.box = box checksumType := s.String("checksum-type", "", "type of the checksum") c.checksumType = checksumType checksum := s.String("checksum", "", "checksum of the box") c.checksum = checksum }