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
}