Documentation

Overview

    Package flags implements utilities to augment the standard Go flag package. It defines commonly used Vanadium flags, and implementations of the flag.Value interface for those flags to ensure that only valid values of those flags are supplied. Some of these flags may also be specified using environment variables directly and are documented accordingly; in these cases the command line value takes precedence over the environment variable.

    Flags are defined as 'groups' of related flags so that the caller may choose which ones to use without having to be burdened with the full set. The groups may be used directly or via the Flags type that aggregates multiple groups. In all cases, the flags are registered with a supplied flag.FlagSet and hence are not forced onto the command line unless the caller passes in flag.CommandLine as the flag.FlagSet to use.

    In general, this package will be used by vanadium profiles and the runtime implementations, but can also be used by any application that wants access to the flags and environment variables it supports.

    Default values are provided for all flags that can be overridden either by calling functions in this package, or globally, by providing an alternative implementation of the ./flags/sitedefaults package. sitedefaults is sub-module that can be overridden using a 'replace' statement in go.mod to provide site specific defaults.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func DefaultCredentialsDir

    func DefaultCredentialsDir() string

      DefaultCredentialsDir returns the current default for --v23.credentials taking V23_CREDENTIALS into account

      func DefaultCredentialsDirNoEnv

      func DefaultCredentialsDirNoEnv() string

        DefaultCredentialsDirNoEnv returns the current default for --v23.credentials ignoring V23_CREDENTIALS

        func DefaultHostPort

        func DefaultHostPort() string

          DefaultHostPort returns the current default host port.

          func DefaultI18nCatalogue

          func DefaultI18nCatalogue() string

            DefaultI18nCatalogue returns the current default for --v23.i18n-catalogue. taking V23_V23_I18N_CATALOGUE into account.

            func DefaultI18nCatalogueNoEnv

            func DefaultI18nCatalogueNoEnv() string

              DefaultI18nCatalogueNoEnv returns the current default for --v23.i18n-catalogue ignoring V23_I18N_CATALOGUE.

              func DefaultNamespaceRoots

              func DefaultNamespaceRoots() []string

                DefaultNamespaceRoots returns the current default value of -v23.namespace.root taking the environment variables V23_NAMESPACE_ROOT0... into account.

                func DefaultNamespaceRootsNoEnv

                func DefaultNamespaceRootsNoEnv() []string

                  DefaultNamespaceRootsNoEnv returns the current default value of -v23.namespace.root ignoring V23_NAMESPACE_ROOT0...

                  func DefaultPermissions

                  func DefaultPermissions() map[string]string

                    DefaultPermissions returns the current default values for --v23.permissions.file as a map.

                    func DefaultPermissionsLiteral

                    func DefaultPermissionsLiteral() string

                      DefaultPermissionsLiteral returns the current default value for --v23.permissions.literal.

                      func DefaultProtocol

                      func DefaultProtocol() string

                        DefaultProtocol returns the current default protocol.

                        func DefaultProxy

                        func DefaultProxy() string

                          DefaultProxy returns the current default proxy.

                          func DefaultProxyLimit

                          func DefaultProxyLimit() int

                            DefaultProxyLimit returns the current default proxy limit.

                            func DefaultProxyPolicy

                            func DefaultProxyPolicy() rpc.ProxyPolicy

                              DefaultProxyPolicy returns the current default proxy policy.

                              func RegisterListenFlags

                              func RegisterListenFlags(fs *flag.FlagSet, f *ListenFlags) error

                                RegisterListenFlags registers the supplied ListenFlags variable with the supplied FlagSet.

                                func RegisterPermissionsFlags

                                func RegisterPermissionsFlags(fs *flag.FlagSet, f *PermissionsFlags) error

                                  RegisterPermissionsFlags registers the supplied PermissionsFlags with the supplied FlagSet.

                                  func RegisterRuntimeFlags

                                  func RegisterRuntimeFlags(fs *flag.FlagSet, f *RuntimeFlags) error

                                    RegisterRuntimeFlags registers the supplied RuntimeFlags variable with the supplied FlagSet.

                                    func RegisterVirtualizedFlags

                                    func RegisterVirtualizedFlags(fs *flag.FlagSet, f *VirtualizedFlags) error

                                      RegisterVirtualizedFlags registers the supplied VirtualizedFlags variable with the supplied FlagSet.

                                      func SetDefaultCredentialsDir

                                      func SetDefaultCredentialsDir(credentialsDir string)

                                        SetDefaultCredentialsDir sets the default value for --v23.credentials. It must be called before flags are parsed for it to take effect.

                                        func SetDefaultHostPort

                                        func SetDefaultHostPort(s string)

                                          SetDefaultHostPort sets the default host and port used when --v23.tcp.address is not provided. It must be called before flags are parsed for it to take effect.

                                          func SetDefaultI18nCatalogue

                                          func SetDefaultI18nCatalogue(i18nCatalogue string)

                                            SetDefaultI18nCatalogue sets the default value for --v23.i18n-catalogue. It must be called before flags are parsed for it to take effect.

                                            func SetDefaultNamespaceRoots

                                            func SetDefaultNamespaceRoots(roots ...string)

                                              SetDefaultNamespaceRoots sets the default value for --v23.namespace.root

                                              func SetDefaultPermissions

                                              func SetDefaultPermissions(name, file string)

                                                SetDefaultPermissions adds a name, file pair to the default value for --v23.permissions.file.

                                                func SetDefaultPermissionsLiteral

                                                func SetDefaultPermissionsLiteral(literal string)

                                                  SetDefaultPermissionsLiteral sets the default value for --v23.permissions.literal.

                                                  func SetDefaultProtocol

                                                  func SetDefaultProtocol(protocol string)

                                                    SetDefaultProtocol sets the default protocol used when --v23.tcp.protocol is not provided. It must be called before flags are parsed for it to take effect.

                                                    func SetDefaultProxy

                                                    func SetDefaultProxy(s string)

                                                      SetDefaultProxy sets the default proxy used when --v23.proxy is not provided. It must be called before flags are parsed for it to take effect.

                                                      func SetDefaultProxyLimit

                                                      func SetDefaultProxyLimit(l int)

                                                        SetDefaultProxyLimit sets the default proxy used when --v23.proxy.limit is not provided. It must be called before flags are parsed for it to take effect.

                                                        func SetDefaultProxyPolicy

                                                        func SetDefaultProxyPolicy(p rpc.ProxyPolicy)

                                                          SetDefaultProxyPolicy sets the default proxy used when --v23.proxy.policy is not provided. It must be called before flags are parsed for it to take effect.

                                                          func SetDefaultVirtualizedFlagValues

                                                          func SetDefaultVirtualizedFlagValues(values VirtualizedFlagDefaults)

                                                            SetDefaultVirtualizedFlagValues sets the default values to use for the Virtualized flags group.

                                                            Types

                                                            type FlagGroup

                                                            type FlagGroup int

                                                              FlagGroup is the type for identifying groups of related flags.

                                                              const (
                                                              	// Runtime identifies the flags and associated environment variables
                                                              	// used by the Vanadium process runtime. Namely:
                                                              	// --v23.namespace.root (which may be repeated to supply multiple values)
                                                              	// --v23.credentials
                                                              	// --v23.i18n-catalogue
                                                              	// --v23.vtrace.sample-rate
                                                              	// --v23.vtrace.dump-on-shutdown
                                                              	// --v23.vtrace.cache-size
                                                              	// --v23.vtrace.collect-regexp
                                                              	Runtime FlagGroup = iota
                                                              	// Listen identifies the flags typically required to configure
                                                              	// rpc.ListenSpec. Namely:
                                                              	// --v23.tcp.protocol
                                                              	// --v23.tcp.address
                                                              	// --v23.proxy
                                                              	// --v23.proxy.policy
                                                              	// --v23.proxy.limit
                                                              	Listen
                                                              	// Permissions identifies the flags typically required to configure
                                                              	// authorization.
                                                              	// --v23.permissions.file (which may be repeated to supply multiple values)
                                                              	// Permissions files are named - i.e. --v23.permissions.file=<name>:<file>
                                                              	// with the name "runtime" reserved for use by the runtime. "file" is
                                                              	// a JSON-encoded representation of the Permissions type defined in the
                                                              	// VDL package v.io/v23/security/access
                                                              	// --v23.permissions.literal (which may be repeated to supply multiple values
                                                              	// which will be concatenated)
                                                              	// This flag allows permissions to specified directly on the command line.
                                                              	Permissions
                                                              	// Virtualized identifies the flags typically required to configure a server
                                                              	// running in some form of virtualized or isolated environment such
                                                              	// as AWS, GCE or within a docker container.
                                                              	// v23.virtualized.docker
                                                              	// v23.virtualized.provider
                                                              	// v23.virtualized.discover-public-address
                                                              	// v23.virtualized.tcp.public-protocol
                                                              	// v23.virtualized.tcp.public-address
                                                              	// v23.virtualized.dns.public-name
                                                              	Virtualized
                                                              )

                                                              type Flags

                                                              type Flags struct {
                                                              	FlagSet *flag.FlagSet
                                                              	// contains filtered or unexported fields
                                                              }

                                                                Flags represents the set of flag groups created by a call to CreateAndRegister.

                                                                func CreateAndRegister

                                                                func CreateAndRegister(fs *flag.FlagSet, groups ...FlagGroup) (*Flags, error)

                                                                  CreateAndRegister creates a new set of flag groups as specified by the supplied flag group parameters and registers them with the supplied flag.FlagSet.

                                                                  func (*Flags) Args

                                                                  func (f *Flags) Args() []string

                                                                    Args returns the unparsed args, as per flag.Args.

                                                                    func (*Flags) HasGroup

                                                                    func (f *Flags) HasGroup(group FlagGroup) bool

                                                                      HasGroup returns group if the supplied FlagGroup has been created for these Flags.

                                                                      func (*Flags) ListenFlags

                                                                      func (f *Flags) ListenFlags() ListenFlags

                                                                        ListenFlags returns a copy of the Listen flag group stored in Flags. This copy will contain default values if the Listen flag group was not specified when CreateAndRegister was called. The HasGroup method can be used for testing to see if any given group was configured.

                                                                        func (*Flags) Parse

                                                                        func (f *Flags) Parse(args []string, cfg map[string]string) error

                                                                          Parse parses the supplied args, as per flag.Parse. The config can optionally specify flag overrides. Any default values modified since the last call to Parse will used.

                                                                          func (*Flags) PermissionsFlags

                                                                          func (f *Flags) PermissionsFlags() PermissionsFlags

                                                                            PermissionsFlags returns a copy of the Permissions flag group stored in Flags. This copy will contain default values if the Permissions flag group was not specified when CreateAndRegister was called. The HasGroup method can be used for testing to see if any given group was configured.

                                                                            func (*Flags) RuntimeFlags

                                                                            func (f *Flags) RuntimeFlags() RuntimeFlags

                                                                              RuntimeFlags returns the Runtime flag subset stored in its Flags instance.

                                                                              func (*Flags) VirtualizedFlags

                                                                              func (f *Flags) VirtualizedFlags() VirtualizedFlags

                                                                                VirtualizedFlags returns a copy of the Virtualized flag group stored in Flags. This copy will contain default values if the Virtualized flag group was not specified when CreateAndRegister was called. The HasGroup method can be used for testing to see if any given group was configured.

                                                                                type HostPortFlag

                                                                                type HostPortFlag struct {
                                                                                	Host string
                                                                                	Port string
                                                                                }

                                                                                  HostPortFlag implements flag.Value to provide validation of the command line value it is set to. The allowed format is <host>:<port>. The host may be specified as a hostname or as an IP address (v4 or v6). A DNS hostname is never resolved.

                                                                                  func (HostPortFlag) Get

                                                                                  func (ip HostPortFlag) Get() interface{}

                                                                                    Get implements flag.Getter.

                                                                                    func (*HostPortFlag) Set

                                                                                    func (ip *HostPortFlag) Set(s string) error

                                                                                      Set implements flag.Value.

                                                                                      func (HostPortFlag) String

                                                                                      func (ip HostPortFlag) String() string

                                                                                        Implements flag.Value.String

                                                                                        type IPFlag

                                                                                        type IPFlag struct{ net.IP }

                                                                                          IPFlag implements flag.Value in order to provide validation of IP addresses in the flag package.

                                                                                          func (IPFlag) Get

                                                                                          func (ip IPFlag) Get() interface{}

                                                                                            Get implements flag.Getter.

                                                                                            func (*IPFlag) Set

                                                                                            func (ip *IPFlag) Set(s string) error

                                                                                              Set implements flag.Value.

                                                                                              func (IPFlag) String

                                                                                              func (ip IPFlag) String() string

                                                                                                Implements flag.Value.String

                                                                                                type IPHostPortFlag

                                                                                                type IPHostPortFlag struct {
                                                                                                	Address string
                                                                                                	Host    string
                                                                                                	IP      []*net.IPAddr
                                                                                                	Port    string
                                                                                                }

                                                                                                  IPHostPortFlag implements flag.Value to provide validation of the command line value it is set to. The allowed format is <host>:<port> in ip4 and ip6 formats. The host may be specified as a hostname or as an IP address (v4 or v6). If a hostname is used and it resolves to multiple IP addresses then all of those addresses are stored in IPHostPort.

                                                                                                  func (IPHostPortFlag) Get

                                                                                                  func (ip IPHostPortFlag) Get() interface{}

                                                                                                    Get implements flag.Getter.

                                                                                                    func (*IPHostPortFlag) Set

                                                                                                    func (ip *IPHostPortFlag) Set(s string) error

                                                                                                      Set implements flag.Value.

                                                                                                      func (IPHostPortFlag) String

                                                                                                      func (ip IPHostPortFlag) String() string

                                                                                                        Implements flag.Value.String

                                                                                                        type ListenAddrs

                                                                                                        type ListenAddrs []struct {
                                                                                                        	Protocol, Address string
                                                                                                        }

                                                                                                          ListenAddrs is the set of listen addresses captured from the command line. ListenAddrs mirrors rpc.ListenAddrs.

                                                                                                          type ListenFlags

                                                                                                          type ListenFlags struct {
                                                                                                          	Addrs       ListenAddrs
                                                                                                          	Proxy       string             `cmdline:"v23.proxy,,object name of proxy service to use to export services across network boundaries"`
                                                                                                          	ProxyPolicy ProxyPolicyFlag    `cmdline:"v23.proxy.policy,,policy for choosing from a set of available proxy instances"`
                                                                                                          	ProxyLimit  int                `` /* 132-byte string literal not displayed */
                                                                                                          	Protocol    tcpProtocolFlagVar `cmdline:"v23.tcp.protocol,,protocol to listen with"`
                                                                                                          	Addresses   ipHostPortFlagVar  `cmdline:"v23.tcp.address,,address to listen on"`
                                                                                                          }

                                                                                                            ListenFlags contains the values of the Listen flag group.

                                                                                                            func CreateAndRegisterListenFlags

                                                                                                            func CreateAndRegisterListenFlags(fs *flag.FlagSet) (*ListenFlags, error)

                                                                                                              CreateAndRegisterListenFlags creates and registers the ListenFlags group with the supplied flag.FlagSet.

                                                                                                              func NewListenFlags

                                                                                                              func NewListenFlags() (*ListenFlags, error)

                                                                                                                NewListenFlags creates a new ListenFlags with appropriate defaults.

                                                                                                                type NamespaceRootFlag

                                                                                                                type NamespaceRootFlag struct {
                                                                                                                	Roots []string
                                                                                                                	// contains filtered or unexported fields
                                                                                                                }

                                                                                                                  NamespaceRootFlag represents a flag.Value for --v23.namespace.root.

                                                                                                                  func (*NamespaceRootFlag) Set

                                                                                                                  func (nsr *NamespaceRootFlag) Set(v string) error

                                                                                                                    Set implements flag.Value

                                                                                                                    func (*NamespaceRootFlag) String

                                                                                                                    func (nsr *NamespaceRootFlag) String() string

                                                                                                                      String implements flag.Value.

                                                                                                                      type PermissionsFlag

                                                                                                                      type PermissionsFlag struct {
                                                                                                                      	// contains filtered or unexported fields
                                                                                                                      }

                                                                                                                        PermissionsFlag represents a flag.Value for --v23.permissions.file

                                                                                                                        func (*PermissionsFlag) Set

                                                                                                                        func (permsf *PermissionsFlag) Set(v string) error

                                                                                                                          Set implements flag.Value.

                                                                                                                          func (*PermissionsFlag) String

                                                                                                                          func (permsf *PermissionsFlag) String() string

                                                                                                                            String implements flag.Value.

                                                                                                                            type PermissionsFlags

                                                                                                                            type PermissionsFlags struct {
                                                                                                                            	// List of named Permissions files.
                                                                                                                            	Files PermissionsFlag `cmdline:"v23.permissions.file,,specify a perms file as <name>:<permsfile>"`
                                                                                                                            
                                                                                                                            	// Literal permissions, override everything else.
                                                                                                                            	Literal PermissionsLiteralFlag `` /* 152-byte string literal not displayed */
                                                                                                                            }

                                                                                                                              PermissionsFlags contains the values of the PermissionsFlags flag group.

                                                                                                                              func CreateAndRegisterPermissionsFlags

                                                                                                                              func CreateAndRegisterPermissionsFlags(fs *flag.FlagSet) (*PermissionsFlags, error)

                                                                                                                                CreateAndRegisterPermissionsFlags creates and registers a PermissionsFlags with the supplied FlagSet.

                                                                                                                                func NewPermissionsFlags

                                                                                                                                func NewPermissionsFlags() (*PermissionsFlags, error)

                                                                                                                                  NewPermissionsFlags creates a PermissionsFlags with appropriate defaults.

                                                                                                                                  func (PermissionsFlags) AddPermissionsFile

                                                                                                                                  func (af PermissionsFlags) AddPermissionsFile(arg string) error

                                                                                                                                    AddPermissionsFile adds a permissions file, which must be in the same format as accepted by --v23.permissions.file

                                                                                                                                    func (PermissionsFlags) AddPermissionsLiteral

                                                                                                                                    func (af PermissionsFlags) AddPermissionsLiteral(arg string) error

                                                                                                                                      AddPermissionsLiteral adds another literal permissions statement.

                                                                                                                                      func (PermissionsFlags) ExplicitlySpecified

                                                                                                                                      func (af PermissionsFlags) ExplicitlySpecified() bool

                                                                                                                                        ExplicitlySpecified returns true if either of the permissions flags was explicitly set on the command line.

                                                                                                                                        func (PermissionsFlags) PermissionsFile

                                                                                                                                        func (af PermissionsFlags) PermissionsFile(name string) string

                                                                                                                                          PermissionsFile returns the file which is presumed to contain Permissions information associated with the supplied name parameter.

                                                                                                                                          func (PermissionsFlags) PermissionsLiteral

                                                                                                                                          func (af PermissionsFlags) PermissionsLiteral() string

                                                                                                                                            PermissionsLiteral returns the in-line literal permissions provided on the command line.

                                                                                                                                            func (PermissionsFlags) PermissionsNamesAndFiles

                                                                                                                                            func (af PermissionsFlags) PermissionsNamesAndFiles() map[string]string

                                                                                                                                              PermissionsNamesAndFiles returns the set of permission names and associated files specified using --v23.permissions.file.

                                                                                                                                              type PermissionsLiteralFlag

                                                                                                                                              type PermissionsLiteralFlag struct {
                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                              }

                                                                                                                                                PermissionsLiteralFlag represents a flag.Value for --v23.permissions.literal

                                                                                                                                                func (*PermissionsLiteralFlag) Set

                                                                                                                                                func (permsl *PermissionsLiteralFlag) Set(v string) error

                                                                                                                                                  Set implements flag.Value.

                                                                                                                                                  func (*PermissionsLiteralFlag) String

                                                                                                                                                  func (permsl *PermissionsLiteralFlag) String() string

                                                                                                                                                    String implements flag.Value.

                                                                                                                                                    type ProxyPolicyFlag

                                                                                                                                                    type ProxyPolicyFlag rpc.ProxyPolicy

                                                                                                                                                    func (ProxyPolicyFlag) Get

                                                                                                                                                    func (policy ProxyPolicyFlag) Get() interface{}

                                                                                                                                                    func (*ProxyPolicyFlag) Set

                                                                                                                                                    func (policy *ProxyPolicyFlag) Set(s string) error

                                                                                                                                                    func (ProxyPolicyFlag) String

                                                                                                                                                    func (policy ProxyPolicyFlag) String() string

                                                                                                                                                    func (ProxyPolicyFlag) Value

                                                                                                                                                    func (policy ProxyPolicyFlag) Value() rpc.ProxyPolicy

                                                                                                                                                    type RuntimeFlags

                                                                                                                                                    type RuntimeFlags struct {
                                                                                                                                                    	// NamespaceRoots may be initialized by ref.EnvNamespacePrefix* enivornment
                                                                                                                                                    	// variables as well as --v23.namespace.root. The command line
                                                                                                                                                    	// will override the environment.
                                                                                                                                                    	NamespaceRoots NamespaceRootFlag `cmdline:"v23.namespace.root,,local namespace root; can be repeated to provided multiple roots"`
                                                                                                                                                    
                                                                                                                                                    	// Credentials may be initialized by the ref.EnvCredentials
                                                                                                                                                    	// environment variable. The command line will override the environment.
                                                                                                                                                    	// TODO(cnicolaou): provide flag.Value impl
                                                                                                                                                    	Credentials string `cmdline:"v23.credentials,,directory to use for storing security credentials"`
                                                                                                                                                    
                                                                                                                                                    	// I18nCatalogue may be initialized by the ref.EnvI18nCatalogueFiles
                                                                                                                                                    	// environment variable.  The command line will override the
                                                                                                                                                    	// environment.
                                                                                                                                                    	I18nCatalogue string `cmdline:"v23.i18n-catalogue,,'18n catalogue files to load, comma separated'"`
                                                                                                                                                    
                                                                                                                                                    	// VtraceFlags control various aspects of Vtrace.
                                                                                                                                                    	VtraceFlags
                                                                                                                                                    }

                                                                                                                                                      RuntimeFlags contains the values of the Runtime flag group.

                                                                                                                                                      func CreateAndRegisterRuntimeFlags

                                                                                                                                                      func CreateAndRegisterRuntimeFlags(fs *flag.FlagSet) (*RuntimeFlags, error)

                                                                                                                                                        CreateAndRegisterRuntimeFlags creates and registers a RuntimeFlags with the supplied flag.FlagSet.

                                                                                                                                                        func NewRuntimeFlags

                                                                                                                                                        func NewRuntimeFlags() (*RuntimeFlags, error)

                                                                                                                                                          NewRuntimeFlags creates a new RuntimeFlags with appropriate defaults.

                                                                                                                                                          type TCPProtocolFlag

                                                                                                                                                          type TCPProtocolFlag struct {
                                                                                                                                                          	Protocol string
                                                                                                                                                          }

                                                                                                                                                            TCPProtocolFlag implements flag.Value to provide validation of the command line values passed to it: tcp, tcp4, tcp6, ws, ws4, ws6, wsh, wsh4, and wsh6 being the only allowed values.

                                                                                                                                                            func (TCPProtocolFlag) Get

                                                                                                                                                            func (t TCPProtocolFlag) Get() interface{}

                                                                                                                                                              Get implements flag.Getter.

                                                                                                                                                              func (*TCPProtocolFlag) Set

                                                                                                                                                              func (t *TCPProtocolFlag) Set(s string) error

                                                                                                                                                                Set implements flag.Value.

                                                                                                                                                                func (TCPProtocolFlag) String

                                                                                                                                                                func (t TCPProtocolFlag) String() string

                                                                                                                                                                  String implements flag.Value.

                                                                                                                                                                  type VirtualizationProvider

                                                                                                                                                                  type VirtualizationProvider string

                                                                                                                                                                    VirtualizationProvider identifies a particular virtualization provider/cloud computing vendor. Popular providers are defined here, but applications may chose to add define and act on others by creating additional runtime factories.

                                                                                                                                                                    const (
                                                                                                                                                                    	// Native is reserved for any/all non-virtualized environments.
                                                                                                                                                                    	Native VirtualizationProvider = ""
                                                                                                                                                                    	// AWS is reserved for Amazon Web Services.
                                                                                                                                                                    	AWS VirtualizationProvider = "AWS"
                                                                                                                                                                    	// GCP is reserved for Google's Compute Platform.
                                                                                                                                                                    	GCP VirtualizationProvider = "GCP"
                                                                                                                                                                    )

                                                                                                                                                                    type VirtualizationProviderFlag

                                                                                                                                                                    type VirtualizationProviderFlag struct {
                                                                                                                                                                    	Provider VirtualizationProvider
                                                                                                                                                                    }

                                                                                                                                                                      VirtualizationProviderFlag represents

                                                                                                                                                                      func (VirtualizationProviderFlag) Get

                                                                                                                                                                      func (vp VirtualizationProviderFlag) Get() interface{}

                                                                                                                                                                        Get implements flat.Getter.

                                                                                                                                                                        func (*VirtualizationProviderFlag) Set

                                                                                                                                                                          Set implements flat.Value.

                                                                                                                                                                          func (*VirtualizationProviderFlag) String

                                                                                                                                                                          func (vp *VirtualizationProviderFlag) String() string

                                                                                                                                                                            String implements flat.Value.

                                                                                                                                                                            type VirtualizedFlagDefaults

                                                                                                                                                                            type VirtualizedFlagDefaults struct {
                                                                                                                                                                            	Dockerized                bool
                                                                                                                                                                            	VirtualizationProvider    string
                                                                                                                                                                            	PublicProtocol            string
                                                                                                                                                                            	PublicAddress             string
                                                                                                                                                                            	PublicDNSName             string
                                                                                                                                                                            	AdvertisePrivateAddresses bool
                                                                                                                                                                            }

                                                                                                                                                                              VirtualizedFlagDefaults is used to set defaults for the Virtualized flag group.

                                                                                                                                                                              func DefaultVirtualizedFlagValues

                                                                                                                                                                              func DefaultVirtualizedFlagValues() VirtualizedFlagDefaults

                                                                                                                                                                                DefaultVirtualizedFlagValues returns the default values to use for the Virtualized flags group taking V23_VIRTUALIZATION_PROVIDER into account. In addition, if V23_EXPECT_GOOGLE_COMPUTE_ENGINE is set then GCP is assumed to be the virtualization provider. V23_EXPECT_GOOGLE_COMPUTE_ENGINE will be removed in the near future (as of 7/30/20). V23_VIRTUALIZATION_PROVIDER will override the effect of V23_EXPECT_GOOGLE_COMPUTE_ENGINE.

                                                                                                                                                                                type VirtualizedFlags

                                                                                                                                                                                type VirtualizedFlags struct {
                                                                                                                                                                                	Dockerized                bool                       `` /* 135-byte string literal not displayed */
                                                                                                                                                                                	VirtualizationProvider    VirtualizationProviderFlag `` /* 163-byte string literal not displayed */
                                                                                                                                                                                	DissallowNativeFallback   bool                       `` /* 175-byte string literal not displayed */
                                                                                                                                                                                	PublicProtocol            TCPProtocolFlag            `cmdline:"v23.virtualized.tcp.public-protocol,,if set the process will use this protocol for its entry in the mounttable"`
                                                                                                                                                                                	PublicAddress             IPHostPortFlag             `` /* 153-byte string literal not displayed */
                                                                                                                                                                                	PublicDNSName             HostPortFlag               `` /* 154-byte string literal not displayed */
                                                                                                                                                                                	AdvertisePrivateAddresses bool                       `cmdline:"v23.virtualized.advertise-private-addresses,,if set the process will also advertise its private addresses"`
                                                                                                                                                                                }

                                                                                                                                                                                  VirtualizedFlags contains the values of the Virtualized flag group.

                                                                                                                                                                                  func CreateAndRegisterVirtualizedFlags

                                                                                                                                                                                  func CreateAndRegisterVirtualizedFlags(fs *flag.FlagSet) (*VirtualizedFlags, error)

                                                                                                                                                                                    CreateAndRegisterVirtualizedFlags creates and registers the VirtualizedFlags group with the supplied flag.FlagSet.

                                                                                                                                                                                    func NewVirtualizedFlags

                                                                                                                                                                                    func NewVirtualizedFlags() (*VirtualizedFlags, error)

                                                                                                                                                                                      NewVirtualizedFlags creates a new VirtualizedFlags with appropriate defaults.

                                                                                                                                                                                      type VtraceFlags

                                                                                                                                                                                      type VtraceFlags struct {
                                                                                                                                                                                      	// VtraceSampleRate is the rate (from 0.0 - 1.0) at which
                                                                                                                                                                                      	// vtrace traces started by this process are sampled for collection.
                                                                                                                                                                                      	SampleRate float64 `cmdline:"v23.vtrace.sample-rate,,Rate (from 0.0 to 1.0) to sample vtrace traces"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// VtraceDumpOnShutdown tells the runtime to dump all stored traces
                                                                                                                                                                                      	// to Stderr at shutdown if true.
                                                                                                                                                                                      	DumpOnShutdown bool `cmdline:"v23.vtrace.dump-on-shutdown,true,'If true, dump all stored traces on runtime shutdown'"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// VtraceCacheSize is the number of traces to cache in memory.
                                                                                                                                                                                      	// TODO(mattr): Traces can be of widely varying size, we should have
                                                                                                                                                                                      	// some better measurement then just number of traces.
                                                                                                                                                                                      	CacheSize int `cmdline:"v23.vtrace.cache-size,1024,The number of vtrace traces to store in memory"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// LogLevel is the level of vlogs that should be collected as part of
                                                                                                                                                                                      	// the trace
                                                                                                                                                                                      	LogLevel int `cmdline:"v23.vtrace.v,,The verbosity level of the log messages to be captured in traces"`
                                                                                                                                                                                      
                                                                                                                                                                                      	// SpanRegexp matches a regular expression against span names and
                                                                                                                                                                                      	// annotations and forces any trace matching trace to be collected.
                                                                                                                                                                                      	CollectRegexp string `cmdline:"v23.vtrace.collect-regexp,,Spans and annotations that match this regular expression will trigger trace collection"`
                                                                                                                                                                                      }

                                                                                                                                                                                        VtraceFlags represents the flags used to configure rpc tracing.

                                                                                                                                                                                        Directories

                                                                                                                                                                                        Path Synopsis
                                                                                                                                                                                        sitedefaults module