func init() {
// make sure Mayu logs to stderr
if err := flag.Lookup("logtostderr").Value.Set("true"); err != nil {
panic(err)
}
// Map any flags registered in the standard "flag" package into the
// top-level mayu command (eg. log flags)
pf := mainCmd.PersistentFlags()
flag.VisitAll(func(f *flag.Flag) {
pf.AddFlag(pflag.PFlagFromGoFlag(f))
})
pf.BoolVarP(&globalFlags.debug, "debug", "d", false, "Print debug output")
pf.BoolVar(&globalFlags.version, "version", false, "Show the version of Mayu")
pf.StringVar(&globalFlags.configFile, "config", DefaultConfigFile, "Path to the configuration file")
pf.StringVar(&globalFlags.clusterDir, "cluster-directory", DefaultClusterDirectory, "Path to the cluster directory")
pf.BoolVar(&globalFlags.showTemplates, "show-templates", DefaultShowTemplates, "Show the templates and quit")
pf.BoolVar(&globalFlags.noGit, "no-git", DefaultNoGit, "Disable git operations")
pf.BoolVar(&globalFlags.noTLS, "no-tls", DefaultNoTLS, "Disable tls")
pf.StringVar(&globalFlags.tFTPRoot, "tftproot", DefaultTFTPRoot, "Path to the tftproot")
pf.StringVar(&globalFlags.yochuPath, "yochu-path", DefaultYochuPath, "Path to Yochus assets (eg docker, etcd, rkt binaries)")
pf.StringVar(&globalFlags.staticHTMLPath, "static-html-path", DefaultStaticHTMLPath, "Path to Mayus binaries (eg. mayuctl, infopusher)")
pf.StringVar(&globalFlags.firstStageScript, "first-stage-script", DefaultFirstStageScript, "Install script to install CoreOS on disk in the first stage.")
pf.StringVar(&globalFlags.lastStageCloudconfig, "last-stage-cloudconfig", DefaultLastStageCloudconfig, "Final cloudconfig that is used to boot the machine")
pf.StringVar(&globalFlags.ignitionConfig, "ignition-config", DefaultIgnitionConfig, "Final ignition config file that is used to boot the machine")
pf.BoolVar(&globalFlags.useIgnition, "use-ignition", false, "Use ignition configuration setup")
pf.StringVar(&globalFlags.dnsmasqTemplate, "dnsmasq-template", DefaultDnsmasqTemplate, "Dnsmasq config template")
pf.StringVar(&globalFlags.templateSnippets, "template-snippets", DefaultTemplateSnippets, "Cloudconfig or Ignition template snippets (eg storage or network configuration)")
pf.StringVar(&globalFlags.dnsmasq, "dnsmasq", DefaultDNSMasq, "Path to dnsmasq binary")
pf.StringVar(&globalFlags.imagesCacheDir, "images-cache-dir", DefaultImagesCacheDir, "Directory for CoreOS images")
pf.IntVar(&globalFlags.httpPort, "http-port", DefaultHTTPPort, "HTTP port Mayu listens on")
pf.StringVar(&globalFlags.httpBindAddress, "http-bind-address", DefaultHTTPBindAddress, "HTTP address Mayu listens on")
pf.StringVar(&globalFlags.tlsCertFile, "tls-cert-file", DefaultTLSCertFile, "Path to tls certificate file")
pf.StringVar(&globalFlags.tlsKeyFile, "tls-key-file", DefaultTLSKeyFile, "Path to tls key file")
pf.BoolVar(&globalFlags.useInternalEtcdDiscovery, "use-internal-etcd-discovery", DefaultUseInternalEtcdDiscovery, "Use the internal etcd discovery")
pf.IntVar(&globalFlags.etcdQuorumSize, "etcd-quorum-size", DefaultEtcdQuorumSize, "Default quorum of the etcd clusters")
pf.StringVar(&globalFlags.etcdDiscoveryUrl, "etcd-discovery", DefaultEtcdDiscoveryUrl, "External etcd discovery base url (eg https://discovery.etcd.io). Note: This should be the base URL of the discovery without a specific token. Mayu itself creates a token for the etcd clusters.")
pf.StringVar(&globalFlags.etcdEndpoint, "etcd-endpoint", DefaultEtcdEndpoint, "The etcd endpoint for the internal discovery feature.")
globalFlags.filesystem = fs.DefaultFilesystem
}
func init() {
// Change the logging defaults for the main cockroach binary.
if err := flag.Lookup(logflags.LogToStderrName).Value.Set("false"); err != nil {
panic(err)
}
// Map any flags registered in the standard "flag" package into the
// top-level cockroach command.
pf := cockroachCmd.PersistentFlags()
flag.VisitAll(func(f *flag.Flag) {
flag := pflag.PFlagFromGoFlag(f)
// TODO(peter): Decide if we want to make the lightstep flags visible.
if strings.HasPrefix(flag.Name, "lightstep_") {
flag.Hidden = true
}
pf.AddFlag(flag)
})
// The --log-dir default changes depending on the command. Avoid confusion by
// simply clearing it.
pf.Lookup(logflags.LogDirName).DefValue = ""
// If no value is specified for --alsologtostderr output everything.
pf.Lookup(logflags.AlsoLogToStderrName).NoOptDefVal = "INFO"
// Security flags.
baseCtx.Insecure = true
insecure = newInsecureValue(baseCtx)
{
f := startCmd.Flags()
// Server flags.
stringFlag(f, &connHost, cliflags.ServerHost, "")
stringFlag(f, &connPort, cliflags.ServerPort, base.DefaultPort)
stringFlag(f, &httpPort, cliflags.ServerHTTPPort, base.DefaultHTTPPort)
stringFlag(f, &httpAddr, cliflags.ServerHTTPAddr, "")
stringFlag(f, &serverCtx.Attrs, cliflags.Attrs, serverCtx.Attrs)
varFlag(f, &serverCtx.Stores, cliflags.Store)
durationFlag(f, &serverCtx.RaftTickInterval, cliflags.RaftTickInterval, base.DefaultRaftTickInterval)
boolFlag(f, &startBackground, cliflags.Background, false)
// Usage for the unix socket is odd as we use a real file, whereas
// postgresql and clients consider it a directory and build a filename
// inside it using the port.
// Thus, we keep it hidden and use it for testing only.
stringFlag(f, &serverCtx.SocketFile, cliflags.Socket, "")
_ = f.MarkHidden(cliflags.Socket.Name)
varFlag(f, insecure, cliflags.Insecure)
// Allow '--insecure'
f.Lookup(cliflags.Insecure.Name).NoOptDefVal = "true"
// Certificate flags.
stringFlag(f, &baseCtx.SSLCA, cliflags.CACert, baseCtx.SSLCA)
stringFlag(f, &baseCtx.SSLCert, cliflags.Cert, baseCtx.SSLCert)
stringFlag(f, &baseCtx.SSLCertKey, cliflags.Key, baseCtx.SSLCertKey)
// Cluster joining flags.
varFlag(f, &serverCtx.JoinList, cliflags.Join)
// Engine flags.
setDefaultCacheSize(&serverCtx)
cacheSize = newBytesValue(&serverCtx.CacheSize)
varFlag(f, cacheSize, cliflags.Cache)
}
for _, cmd := range certCmds {
f := cmd.Flags()
// Certificate flags.
stringFlag(f, &baseCtx.SSLCA, cliflags.CACert, baseCtx.SSLCA)
stringFlag(f, &baseCtx.SSLCAKey, cliflags.CAKey, baseCtx.SSLCAKey)
stringFlag(f, &baseCtx.SSLCert, cliflags.Cert, baseCtx.SSLCert)
stringFlag(f, &baseCtx.SSLCertKey, cliflags.Key, baseCtx.SSLCertKey)
intFlag(f, &keySize, cliflags.KeySize, defaultKeySize)
}
stringFlag(setUserCmd.Flags(), &password, cliflags.Password, "")
clientCmds := []*cobra.Command{
sqlShellCmd, quitCmd, freezeClusterCmd, dumpCmd, /* startCmd is covered above */
}
clientCmds = append(clientCmds, kvCmds...)
clientCmds = append(clientCmds, rangeCmds...)
clientCmds = append(clientCmds, userCmds...)
clientCmds = append(clientCmds, zoneCmds...)
clientCmds = append(clientCmds, nodeCmds...)
clientCmds = append(clientCmds, backupCmds...)
for _, cmd := range clientCmds {
f := cmd.PersistentFlags()
stringFlag(f, &connHost, cliflags.ClientHost, "")
varFlag(f, insecure, cliflags.Insecure)
// Allow '--insecure'
f.Lookup(cliflags.Insecure.Name).NoOptDefVal = "true"
// Certificate flags.
stringFlag(f, &baseCtx.SSLCA, cliflags.CACert, baseCtx.SSLCA)
stringFlag(f, &baseCtx.SSLCert, cliflags.Cert, baseCtx.SSLCert)
stringFlag(f, &baseCtx.SSLCertKey, cliflags.Key, baseCtx.SSLCertKey)
// By default, client commands print their output as
// pretty-formatted tables on terminals, and TSV when redirected
// to a file. The user can override with --pretty.
boolFlag(f, &cliCtx.prettyFmt, cliflags.Pretty, isInteractive)
}
stringFlag(setZoneCmd.Flags(), &zoneConfig, cliflags.ZoneConfig, "")
varFlag(sqlShellCmd.Flags(), &sqlCtx.execStmts, cliflags.Execute)
boolFlag(freezeClusterCmd.PersistentFlags(), &undoFreezeCluster, cliflags.UndoFreezeCluster, false)
// Commands that need the cockroach port.
simpleCmds := []*cobra.Command{quitCmd, freezeClusterCmd}
simpleCmds = append(simpleCmds, kvCmds...)
simpleCmds = append(simpleCmds, rangeCmds...)
simpleCmds = append(simpleCmds, nodeCmds...)
for _, cmd := range simpleCmds {
f := cmd.PersistentFlags()
stringFlag(f, &connPort, cliflags.ClientPort, base.DefaultPort)
}
// Commands that establish a SQL connection.
sqlCmds := []*cobra.Command{sqlShellCmd, dumpCmd}
sqlCmds = append(sqlCmds, zoneCmds...)
sqlCmds = append(sqlCmds, userCmds...)
for _, cmd := range sqlCmds {
f := cmd.PersistentFlags()
stringFlag(f, &connURL, cliflags.URL, "")
stringFlag(f, &connUser, cliflags.User, security.RootUser)
stringFlag(f, &connPort, cliflags.ClientPort, base.DefaultPort)
stringFlag(f, &connDBName, cliflags.Database, "")
}
// Max results flag for scan, reverse scan, and range list.
for _, cmd := range []*cobra.Command{scanCmd, reverseScanCmd, lsRangesCmd} {
f := cmd.Flags()
int64Flag(f, &maxResults, cliflags.MaxResults, 1000)
}
// Debug commands.
{
f := debugKeysCmd.Flags()
varFlag(f, (*mvccKey)(&debugCtx.startKey), cliflags.From)
varFlag(f, (*mvccKey)(&debugCtx.endKey), cliflags.To)
boolFlag(f, &debugCtx.values, cliflags.Values, false)
boolFlag(f, &debugCtx.sizes, cliflags.Sizes, false)
}
boolFlag(versionCmd.Flags(), &versionIncludesDeps, cliflags.Deps, false)
cobra.OnInitialize(extraFlagInit)
}
func init() {
// Change the logging defaults for the main cockroach binary.
if err := flag.Lookup(logflags.LogToStderrName).Value.Set("false"); err != nil {
panic(err)
}
// Map any flags registered in the standard "flag" package into the
// top-level cockroach command.
pf := cockroachCmd.PersistentFlags()
flag.VisitAll(func(f *flag.Flag) {
flag := pflag.PFlagFromGoFlag(f)
// TODO(peter): Decide if we want to make the lightstep flags visible.
if strings.HasPrefix(flag.Name, "lightstep_") {
flag.Hidden = true
}
pf.AddFlag(flag)
})
// The --log-dir default changes depending on the command. Avoid confusion by
// simply clearing it.
pf.Lookup(logflags.LogDirName).DefValue = ""
// If no value is specified for --alsologtostderr output everything.
pf.Lookup(logflags.AlsoLogToStderrName).NoOptDefVal = "INFO"
// Security flags.
baseCtx.Insecure = true
insecure = newInsecureValue(baseCtx)
{
f := startCmd.Flags()
// Server flags.
f.StringVar(&connHost, cliflags.HostName, "", usageNoEnv(forServer(cliflags.HostName)))
f.StringVarP(&connPort, cliflags.PortName, "p", base.DefaultPort, usageNoEnv(forServer(cliflags.PortName)))
f.StringVar(&httpPort, cliflags.HTTPPortName, base.DefaultHTTPPort, usageNoEnv(forServer(cliflags.HTTPPortName)))
f.StringVar(&serverCtx.Attrs, cliflags.AttrsName, serverCtx.Attrs, usageNoEnv(cliflags.AttrsName))
f.VarP(&serverCtx.Stores, cliflags.StoreName, "s", usageNoEnv(cliflags.StoreName))
f.DurationVar(&serverCtx.RaftTickInterval, cliflags.RaftTickIntervalName, base.DefaultRaftTickInterval, usageNoEnv(cliflags.RaftTickIntervalName))
f.BoolVar(&startBackground, cliflags.BackgroundName, false, usageNoEnv(cliflags.BackgroundName))
// Usage for the unix socket is odd as we use a real file, whereas
// postgresql and clients consider it a directory and build a filename
// inside it using the port.
// Thus, we keep it hidden and use it for testing only.
f.StringVar(&serverCtx.SocketFile, cliflags.SocketName, "", usageEnv(cliflags.SocketName))
_ = f.MarkHidden(cliflags.SocketName)
insecureF := f.VarPF(insecure, cliflags.InsecureName, "", usageEnv(cliflags.InsecureName))
insecureF.NoOptDefVal = envutil.EnvOrDefaultString(cliflags.InsecureName, "true")
// Certificate flags.
f.StringVar(&baseCtx.SSLCA, cliflags.CACertName, baseCtx.SSLCA, usageNoEnv(cliflags.CACertName))
f.StringVar(&baseCtx.SSLCert, cliflags.CertName, baseCtx.SSLCert, usageNoEnv(cliflags.CertName))
f.StringVar(&baseCtx.SSLCertKey, cliflags.KeyName, baseCtx.SSLCertKey, usageNoEnv(cliflags.KeyName))
// Cluster joining flags.
f.StringVar(&serverCtx.JoinUsing, cliflags.JoinName, serverCtx.JoinUsing, usageNoEnv(cliflags.JoinName))
// Engine flags.
setDefaultCacheSize(&serverCtx)
cacheSize = newBytesValue(&serverCtx.CacheSize)
f.Var(cacheSize, cliflags.CacheName, usageNoEnv(cliflags.CacheName))
}
for _, cmd := range certCmds {
f := cmd.Flags()
// Certificate flags.
f.StringVar(&baseCtx.SSLCA, cliflags.CACertName, baseCtx.SSLCA, usageNoEnv(cliflags.CACertName))
f.StringVar(&baseCtx.SSLCAKey, cliflags.CAKeyName, baseCtx.SSLCAKey, usageNoEnv(cliflags.CAKeyName))
f.StringVar(&baseCtx.SSLCert, cliflags.CertName, baseCtx.SSLCert, usageNoEnv(cliflags.CertName))
f.StringVar(&baseCtx.SSLCertKey, cliflags.KeyName, baseCtx.SSLCertKey, usageNoEnv(cliflags.KeyName))
f.IntVar(&keySize, cliflags.KeySizeName, defaultKeySize, usageNoEnv(cliflags.KeySizeName))
}
setUserCmd.Flags().StringVar(&password, cliflags.PasswordName, envutil.EnvOrDefaultString(cliflags.PasswordName, ""), usageEnv(cliflags.PasswordName))
clientCmds := []*cobra.Command{
sqlShellCmd, quitCmd, freezeClusterCmd, dumpCmd, /* startCmd is covered above */
}
clientCmds = append(clientCmds, kvCmds...)
clientCmds = append(clientCmds, rangeCmds...)
clientCmds = append(clientCmds, userCmds...)
clientCmds = append(clientCmds, zoneCmds...)
clientCmds = append(clientCmds, nodeCmds...)
for _, cmd := range clientCmds {
f := cmd.PersistentFlags()
f.StringVar(&connHost, cliflags.HostName, envutil.EnvOrDefaultString(cliflags.HostName, ""), usageEnv(forClient(cliflags.HostName)))
insecureF := f.VarPF(insecure, cliflags.InsecureName, "", usageEnv(cliflags.InsecureName))
insecureF.NoOptDefVal = envutil.EnvOrDefaultString(cliflags.InsecureName, "true")
// Certificate flags.
f.StringVar(&baseCtx.SSLCA, cliflags.CACertName, envutil.EnvOrDefaultString(cliflags.CACertName, baseCtx.SSLCA), usageEnv(cliflags.CACertName))
f.StringVar(&baseCtx.SSLCert, cliflags.CertName, envutil.EnvOrDefaultString(cliflags.CertName, baseCtx.SSLCert), usageEnv(cliflags.CertName))
f.StringVar(&baseCtx.SSLCertKey, cliflags.KeyName, envutil.EnvOrDefaultString(cliflags.KeyName, baseCtx.SSLCertKey), usageEnv(cliflags.KeyName))
// By default, client commands print their output as
// pretty-formatted tables on terminals, and TSV when redirected
// to a file. The user can override with --pretty.
f.BoolVar(&cliCtx.prettyFmt, cliflags.PrettyName, isInteractive, usageNoEnv(cliflags.PrettyName))
}
{
f := sqlShellCmd.Flags()
f.VarP(&sqlCtx.execStmts, cliflags.ExecuteName, "e", usageNoEnv(cliflags.ExecuteName))
}
{
f := freezeClusterCmd.PersistentFlags()
f.BoolVar(&undoFreezeCluster, cliflags.UndoFreezeClusterName, false, usageNoEnv(cliflags.UndoFreezeClusterName))
}
// Commands that need the cockroach port.
simpleCmds := []*cobra.Command{quitCmd, freezeClusterCmd}
simpleCmds = append(simpleCmds, kvCmds...)
simpleCmds = append(simpleCmds, rangeCmds...)
simpleCmds = append(simpleCmds, nodeCmds...)
for _, cmd := range simpleCmds {
f := cmd.PersistentFlags()
f.StringVarP(&connPort, cliflags.PortName, "p", envutil.EnvOrDefaultString(cliflags.PortName, base.DefaultPort), usageEnv(forClient(cliflags.PortName)))
}
// Commands that establish a SQL connection.
sqlCmds := []*cobra.Command{sqlShellCmd, dumpCmd}
sqlCmds = append(sqlCmds, zoneCmds...)
sqlCmds = append(sqlCmds, userCmds...)
for _, cmd := range sqlCmds {
f := cmd.PersistentFlags()
f.StringVar(&connURL, cliflags.URLName, envutil.EnvOrDefaultString(cliflags.URLName, ""), usageEnv(cliflags.URLName))
f.StringVarP(&connUser, cliflags.UserName, "u", envutil.EnvOrDefaultString(cliflags.UserName, security.RootUser), usageEnv(cliflags.UserName))
f.StringVarP(&connPort, cliflags.PortName, "p", envutil.EnvOrDefaultString(cliflags.PortName, base.DefaultPort), usageEnv(forClient(cliflags.PortName)))
f.StringVarP(&connDBName, cliflags.DatabaseName, "d", envutil.EnvOrDefaultString(cliflags.DatabaseName, ""), usageEnv(cliflags.DatabaseName))
}
// Max results flag for scan, reverse scan, and range list.
for _, cmd := range []*cobra.Command{scanCmd, reverseScanCmd, lsRangesCmd} {
f := cmd.Flags()
f.Int64Var(&maxResults, cliflags.MaxResultsName, 1000, usageNoEnv(cliflags.MaxResultsName))
}
// Debug commands.
{
f := debugKeysCmd.Flags()
f.Var((*mvccKey)(&debugCtx.startKey), cliflags.FromName, usageNoEnv(cliflags.FromName))
f.Var((*mvccKey)(&debugCtx.endKey), cliflags.ToName, usageNoEnv(cliflags.ToName))
f.BoolVar(&debugCtx.values, cliflags.ValuesName, false, usageNoEnv(cliflags.ValuesName))
f.BoolVar(&debugCtx.sizes, cliflags.SizesName, false, usageNoEnv(cliflags.SizesName))
}
{
f := versionCmd.Flags()
f.BoolVar(&versionIncludesDeps, cliflags.DepsName, false, usageNoEnv(cliflags.DepsName))
}
cobra.OnInitialize(func() {
// If any of the security flags have been set, clear the insecure
// setting. Note that we do the inverse when the --insecure flag is
// set. See insecureValue.Set().
if baseCtx.SSLCA != "" || baseCtx.SSLCAKey != "" ||
baseCtx.SSLCert != "" || baseCtx.SSLCertKey != "" {
baseCtx.Insecure = false
}
serverCtx.Addr = net.JoinHostPort(connHost, connPort)
serverCtx.HTTPAddr = net.JoinHostPort(connHost, httpPort)
})
}
// initFlags sets the cli.Context values to flag values.
// Keep in sync with "server/context.go". Values in Context should be
// settable here.
func initFlags(ctx *Context) {
// Change the logging defaults for the main cockroach binary.
if err := flag.Lookup("logtostderr").Value.Set("false"); err != nil {
panic(err)
}
// Map any flags registered in the standard "flag" package into the
// top-level cockroach command.
pf := cockroachCmd.PersistentFlags()
flag.VisitAll(func(f *flag.Flag) {
pf.AddFlag(pflag.PFlagFromGoFlag(f))
})
// The --log-dir default changes depending on the command. Avoid confusion by
// simply clearing it.
pf.Lookup("log-dir").DefValue = ""
// If no value is specified for --alsologtostderr output everything.
pf.Lookup("alsologtostderr").NoOptDefVal = "INFO"
{
f := startCmd.Flags()
// Server flags.
f.StringVar(&connHost, "host", "", usage("server_host"))
f.StringVarP(&connPort, "port", "p", base.DefaultPort, usage("server_port"))
f.StringVar(&httpPort, "http-port", base.DefaultHTTPPort, usage("server_http_port"))
f.StringVar(&ctx.Attrs, "attrs", ctx.Attrs, usage("attrs"))
f.VarP(&ctx.Stores, "store", "s", usage("store"))
// Security flags.
f.BoolVar(&ctx.Insecure, "insecure", ctx.Insecure, usage("insecure"))
// Certificates.
f.StringVar(&ctx.SSLCA, "ca-cert", ctx.SSLCA, usage("ca-cert"))
f.StringVar(&ctx.SSLCert, "cert", ctx.SSLCert, usage("cert"))
f.StringVar(&ctx.SSLCertKey, "key", ctx.SSLCertKey, usage("key"))
// Cluster joining flags.
f.StringVar(&ctx.JoinUsing, "join", ctx.JoinUsing, usage("join"))
// Engine flags.
cacheSize = newBytesValue(&ctx.CacheSize)
f.Var(cacheSize, "cache", usage("cache"))
// Clear the cache default value. This flag does have a default, but
// it is set only when the "start" command is run.
f.Lookup("cache").DefValue = ""
if err := startCmd.MarkFlagRequired("store"); err != nil {
panic(err)
}
}
{
f := exterminateCmd.Flags()
f.Var(&ctx.Stores, "store", usage("store"))
if err := exterminateCmd.MarkFlagRequired("store"); err != nil {
panic(err)
}
}
for _, cmd := range certCmds {
f := cmd.Flags()
// Certificate flags.
f.StringVar(&ctx.SSLCA, "ca-cert", ctx.SSLCA, usage("ca-cert"))
f.StringVar(&ctx.SSLCAKey, "ca-key", ctx.SSLCAKey, usage("ca-key"))
f.StringVar(&ctx.SSLCert, "cert", ctx.SSLCert, usage("cert"))
f.StringVar(&ctx.SSLCertKey, "key", ctx.SSLCertKey, usage("key"))
f.IntVar(&keySize, "key-size", defaultKeySize, usage("key-size"))
if err := cmd.MarkFlagRequired("key-size"); err != nil {
panic(err)
}
}
setUserCmd.Flags().StringVar(&password, "password", "", usage("password"))
clientCmds := []*cobra.Command{
sqlShellCmd, exterminateCmd, quitCmd, /* startCmd is covered above */
}
clientCmds = append(clientCmds, kvCmds...)
clientCmds = append(clientCmds, rangeCmds...)
clientCmds = append(clientCmds, userCmds...)
clientCmds = append(clientCmds, zoneCmds...)
clientCmds = append(clientCmds, nodeCmds...)
for _, cmd := range clientCmds {
f := cmd.PersistentFlags()
f.BoolVar(&ctx.Insecure, "insecure", ctx.Insecure, usage("insecure"))
f.StringVar(&connHost, "host", "", usage("client_host"))
// Certificate flags.
f.StringVar(&ctx.SSLCA, "ca-cert", ctx.SSLCA, usage("ca-cert"))
f.StringVar(&ctx.SSLCert, "cert", ctx.SSLCert, usage("cert"))
f.StringVar(&ctx.SSLCertKey, "key", ctx.SSLCertKey, usage("key"))
}
{
f := sqlShellCmd.Flags()
f.VarP(&ctx.execStmts, "execute", "e", usage("execute"))
}
// Commands that need the cockroach port.
simpleCmds := []*cobra.Command{exterminateCmd}
simpleCmds = append(simpleCmds, kvCmds...)
simpleCmds = append(simpleCmds, rangeCmds...)
for _, cmd := range simpleCmds {
f := cmd.PersistentFlags()
f.StringVarP(&connPort, "port", "p", base.DefaultPort, usage("client_port"))
}
// Commands that need an http port.
httpCmds := []*cobra.Command{quitCmd}
httpCmds = append(httpCmds, nodeCmds...)
for _, cmd := range httpCmds {
f := cmd.PersistentFlags()
f.StringVar(&httpPort, "http-port", base.DefaultHTTPPort, usage("client_http_port"))
}
// Commands that establish a SQL connection.
sqlCmds := []*cobra.Command{sqlShellCmd}
sqlCmds = append(sqlCmds, zoneCmds...)
sqlCmds = append(sqlCmds, userCmds...)
for _, cmd := range sqlCmds {
f := cmd.PersistentFlags()
f.StringVar(&connURL, "url", "", usage("url"))
f.StringVarP(&connUser, "user", "u", security.RootUser, usage("user"))
f.StringVarP(&connPort, "port", "p", base.DefaultPort, usage("client_port"))
f.StringVarP(&connDBName, "database", "d", "", usage("database"))
}
// Max results flag for scan, reverse scan, and range list.
for _, cmd := range []*cobra.Command{scanCmd, reverseScanCmd, lsRangesCmd} {
f := cmd.Flags()
f.Int64Var(&maxResults, "max-results", 1000, usage("max-results"))
}
}
// initFlags sets the cli.Context values to flag values.
// Keep in sync with "server/context.go". Values in Context should be
// settable here.
func initFlags(ctx *Context) {
// Change the logging defaults for the main cockroach binary.
if err := flag.Lookup(logflags.LogToStderrName).Value.Set("false"); err != nil {
panic(err)
}
// Map any flags registered in the standard "flag" package into the
// top-level cockroach command.
pf := cockroachCmd.PersistentFlags()
flag.VisitAll(func(f *flag.Flag) {
pf.AddFlag(pflag.PFlagFromGoFlag(f))
})
// The --log-dir default changes depending on the command. Avoid confusion by
// simply clearing it.
pf.Lookup(logflags.LogDirName).DefValue = ""
// If no value is specified for --alsologtostderr output everything.
pf.Lookup(logflags.AlsoLogToStderrName).NoOptDefVal = "INFO"
{
f := startCmd.Flags()
// Server flags.
f.StringVar(&connHost, cliflags.HostName, "", usageNoEnv(forServer(cliflags.HostName)))
f.StringVarP(&connPort, cliflags.PortName, "p", base.DefaultPort, usageNoEnv(forServer(cliflags.PortName)))
f.StringVar(&httpPort, cliflags.HTTPPortName, base.DefaultHTTPPort, usageNoEnv(forServer(cliflags.HTTPPortName)))
f.StringVar(&ctx.Attrs, cliflags.AttrsName, ctx.Attrs, usageNoEnv(cliflags.AttrsName))
f.VarP(&ctx.Stores, cliflags.StoreName, "s", usageNoEnv(cliflags.StoreName))
// Usage for the unix socket is odd as we use a real file, whereas
// postgresql and clients consider it a directory and build a filename
// inside it using the port.
// Thus, we keep it hidden and use it for testing only.
f.StringVar(&ctx.SocketFile, cliflags.SocketName, "", usageEnv(cliflags.SocketName))
_ = f.MarkHidden(cliflags.SocketName)
// Security flags.
ctx.Insecure = true
insecure = newInsecureValue(&ctx.Insecure)
insecureF := f.VarPF(insecure, cliflags.InsecureName, "", usageNoEnv(cliflags.InsecureName))
insecureF.NoOptDefVal = "true"
// Certificates.
f.StringVar(&ctx.SSLCA, cliflags.CACertName, ctx.SSLCA, usageNoEnv(cliflags.CACertName))
f.StringVar(&ctx.SSLCert, cliflags.CertName, ctx.SSLCert, usageNoEnv(cliflags.CertName))
f.StringVar(&ctx.SSLCertKey, cliflags.KeyName, ctx.SSLCertKey, usageNoEnv(cliflags.KeyName))
// Cluster joining flags.
f.StringVar(&ctx.JoinUsing, cliflags.JoinName, ctx.JoinUsing, usageNoEnv(cliflags.JoinName))
// Engine flags.
setDefaultCacheSize(&ctx.Context)
cacheSize = newBytesValue(&ctx.CacheSize)
f.Var(cacheSize, cliflags.CacheName, usageNoEnv(cliflags.CacheName))
if err := startCmd.MarkFlagRequired(cliflags.StoreName); err != nil {
panic(err)
}
}
{
f := exterminateCmd.Flags()
f.Var(&ctx.Stores, cliflags.StoreName, usageNoEnv(cliflags.StoreName))
if err := exterminateCmd.MarkFlagRequired(cliflags.StoreName); err != nil {
panic(err)
}
}
for _, cmd := range certCmds {
f := cmd.Flags()
// Certificate flags.
f.StringVar(&ctx.SSLCA, cliflags.CACertName, ctx.SSLCA, usageNoEnv(cliflags.CACertName))
f.StringVar(&ctx.SSLCAKey, cliflags.CAKeyName, ctx.SSLCAKey, usageNoEnv(cliflags.CAKeyName))
f.StringVar(&ctx.SSLCert, cliflags.CertName, ctx.SSLCert, usageNoEnv(cliflags.CertName))
f.StringVar(&ctx.SSLCertKey, cliflags.KeyName, ctx.SSLCertKey, usageNoEnv(cliflags.KeyName))
f.IntVar(&keySize, cliflags.KeySizeName, defaultKeySize, usageNoEnv(cliflags.KeySizeName))
if err := cmd.MarkFlagRequired(cliflags.KeySizeName); err != nil {
panic(err)
}
}
setUserCmd.Flags().StringVar(&password, cliflags.PasswordName, envutil.EnvOrDefaultString(cliflags.PasswordName, ""), usageEnv(cliflags.PasswordName))
clientCmds := []*cobra.Command{
sqlShellCmd, exterminateCmd, quitCmd, /* startCmd is covered above */
}
clientCmds = append(clientCmds, kvCmds...)
clientCmds = append(clientCmds, rangeCmds...)
clientCmds = append(clientCmds, userCmds...)
clientCmds = append(clientCmds, zoneCmds...)
clientCmds = append(clientCmds, nodeCmds...)
for _, cmd := range clientCmds {
f := cmd.PersistentFlags()
insecureF := f.VarPF(insecure, cliflags.InsecureName, "", usageEnv(cliflags.InsecureName))
insecureF.NoOptDefVal = envutil.EnvOrDefaultString(cliflags.InsecureName, "true")
f.StringVar(&connHost, cliflags.HostName, envutil.EnvOrDefaultString(cliflags.HostName, ""), usageEnv(forClient(cliflags.HostName)))
// Certificate flags.
f.StringVar(&ctx.SSLCA, cliflags.CACertName, envutil.EnvOrDefaultString(cliflags.CACertName, ctx.SSLCA), usageEnv(cliflags.CACertName))
f.StringVar(&ctx.SSLCert, cliflags.CertName, envutil.EnvOrDefaultString(cliflags.CertName, ctx.SSLCert), usageEnv(cliflags.CertName))
f.StringVar(&ctx.SSLCertKey, cliflags.KeyName, envutil.EnvOrDefaultString(cliflags.KeyName, ctx.SSLCertKey), usageEnv(cliflags.KeyName))
}
{
f := sqlShellCmd.Flags()
f.VarP(&ctx.execStmts, cliflags.ExecuteName, "e", usageNoEnv(cliflags.ExecuteName))
}
// Commands that need the cockroach port.
simpleCmds := []*cobra.Command{exterminateCmd}
simpleCmds = append(simpleCmds, kvCmds...)
simpleCmds = append(simpleCmds, rangeCmds...)
for _, cmd := range simpleCmds {
f := cmd.PersistentFlags()
f.StringVarP(&connPort, cliflags.PortName, "p", envutil.EnvOrDefaultString(cliflags.PortName, base.DefaultPort), usageEnv(forClient(cliflags.PortName)))
}
// Commands that need an http port.
httpCmds := []*cobra.Command{quitCmd}
httpCmds = append(httpCmds, nodeCmds...)
for _, cmd := range httpCmds {
f := cmd.PersistentFlags()
f.StringVar(&httpPort, cliflags.HTTPPortName, envutil.EnvOrDefaultString(cliflags.HTTPPortName, base.DefaultHTTPPort), usageEnv(forClient(cliflags.HTTPPortName)))
}
// Commands that establish a SQL connection.
sqlCmds := []*cobra.Command{sqlShellCmd}
sqlCmds = append(sqlCmds, zoneCmds...)
sqlCmds = append(sqlCmds, userCmds...)
for _, cmd := range sqlCmds {
f := cmd.PersistentFlags()
f.StringVar(&connURL, cliflags.URLName, envutil.EnvOrDefaultString(cliflags.URLName, ""), usageEnv(cliflags.URLName))
f.StringVarP(&connUser, cliflags.UserName, "u", envutil.EnvOrDefaultString(cliflags.UserName, security.RootUser), usageEnv(cliflags.UserName))
f.StringVarP(&connPort, cliflags.PortName, "p", envutil.EnvOrDefaultString(cliflags.PortName, base.DefaultPort), usageEnv(forClient(cliflags.PortName)))
f.StringVarP(&connDBName, cliflags.DatabaseName, "d", envutil.EnvOrDefaultString(cliflags.DatabaseName, ""), usageEnv(cliflags.DatabaseName))
}
// Max results flag for scan, reverse scan, and range list.
for _, cmd := range []*cobra.Command{scanCmd, reverseScanCmd, lsRangesCmd} {
f := cmd.Flags()
f.Int64Var(&maxResults, cliflags.MaxResultsName, 1000, usageNoEnv(cliflags.MaxResultsName))
}
// Debug commands.
{
f := debugKeysCmd.Flags()
f.StringVar(&cliContext.debug.startKey, cliflags.FromName, "", usageEnv(cliflags.FromName))
f.StringVar(&cliContext.debug.endKey, cliflags.ToName, "", usageEnv(cliflags.ToName))
f.BoolVar(&cliContext.debug.raw, cliflags.RawName, false, usageEnv(cliflags.RawName))
f.BoolVar(&cliContext.debug.values, cliflags.ValuesName, false, usageEnv(cliflags.ValuesName))
}
{
f := versionCmd.Flags()
f.BoolVar(&versionIncludesDeps, cliflags.DepsName, false, usageEnv(cliflags.DepsName))
}
}
// initFlags sets the cli.Context values to flag values.
// Keep in sync with "server/context.go". Values in Context should be
// settable here.
func initFlags(ctx *Context) {
// Change the logging defaults for the main cockroach binary.
if err := flag.Lookup("logtostderr").Value.Set("false"); err != nil {
panic(err)
}
// Map any flags registered in the standard "flag" package into the
// top-level cockroach command.
pf := cockroachCmd.PersistentFlags()
flag.VisitAll(func(f *flag.Flag) {
pf.AddFlag(pflag.PFlagFromGoFlag(f))
})
// The --log-dir default changes depending on the command. Avoid confusion by
// simply clearing it.
pf.Lookup("log-dir").DefValue = ""
// If no value is specified for --alsologtostderr output everything.
pf.Lookup("alsologtostderr").NoOptDefVal = "INFO"
{
f := startCmd.Flags()
// Server flags.
f.StringVar(&connHost, "host", "", usage("server_host"))
f.StringVarP(&connPort, "port", "p", base.DefaultPort, usage("server_port"))
f.StringVar(&ctx.Attrs, "attrs", ctx.Attrs, usage("attrs"))
f.VarP(&ctx.Stores, "store", "s", usage("store"))
f.DurationVar(&ctx.MaxOffset, "max-offset", ctx.MaxOffset, usage("max-offset"))
f.DurationVar(&ctx.MetricsFrequency, "metrics-frequency", ctx.MetricsFrequency, usage("metrics-frequency"))
f.Var(&ctx.BalanceMode, "balance-mode", usage("balance-mode"))
// Security flags.
f.StringVar(&ctx.Certs, "certs", ctx.Certs, usage("certs"))
f.BoolVar(&ctx.Insecure, "insecure", ctx.Insecure, usage("insecure"))
// Cluster joining flags.
f.StringVar(&ctx.JoinUsing, "join", ctx.JoinUsing, usage("join"))
// KV flags.
f.BoolVar(&ctx.Linearizable, "linearizable", ctx.Linearizable, usage("linearizable"))
// Engine flags.
cacheSize = newBytesValue(&ctx.CacheSize)
f.Var(cacheSize, "cache-size", usage("cache-size"))
f.Var(newBytesValue(&ctx.MemtableBudget), "memtable-budget", usage("memtable-budget"))
f.DurationVar(&ctx.ScanInterval, "scan-interval", ctx.ScanInterval, usage("scan-interval"))
f.DurationVar(&ctx.ScanMaxIdleTime, "scan-max-idle-time", ctx.ScanMaxIdleTime, usage("scan-max-idle-time"))
f.DurationVar(&ctx.TimeUntilStoreDead, "time-until-store-dead", ctx.TimeUntilStoreDead, usage("time-until-store-dead"))
// Clear the cache-size default value. This flag does have a default, but
// it is set only when the "start" command is run.
f.Lookup("cache-size").DefValue = ""
if err := startCmd.MarkFlagRequired("store"); err != nil {
panic(err)
}
}
{
f := exterminateCmd.Flags()
f.Var(&ctx.Stores, "store", usage("store"))
if err := exterminateCmd.MarkFlagRequired("store"); err != nil {
panic(err)
}
}
for _, cmd := range certCmds {
f := cmd.Flags()
f.StringVar(&ctx.Certs, "certs", ctx.Certs, usage("certs"))
f.IntVar(&keySize, "key-size", defaultKeySize, usage("key-size"))
if err := cmd.MarkFlagRequired("certs"); err != nil {
panic(err)
}
if err := cmd.MarkFlagRequired("key-size"); err != nil {
panic(err)
}
}
setUserCmd.Flags().StringVar(&password, "password", "", usage("password"))
clientCmds := []*cobra.Command{
sqlShellCmd, kvCmd, rangeCmd,
userCmd, zoneCmd, nodeCmd,
exterminateCmd, quitCmd, /* startCmd is covered above */
}
for _, cmd := range clientCmds {
f := cmd.PersistentFlags()
f.BoolVar(&ctx.Insecure, "insecure", ctx.Insecure, usage("insecure"))
f.StringVar(&ctx.Certs, "certs", ctx.Certs, usage("certs"))
f.StringVar(&connHost, "host", "", usage("client_host"))
}
{
f := sqlShellCmd.Flags()
f.BoolVarP(&ctx.OneShotSQL, "execute", "e", ctx.OneShotSQL, usage("execute"))
}
// Commands that need the cockroach port.
simpleCmds := []*cobra.Command{kvCmd, nodeCmd, rangeCmd, exterminateCmd, quitCmd}
for _, cmd := range simpleCmds {
f := cmd.PersistentFlags()
f.StringVarP(&connPort, "port", "p", base.DefaultPort, usage("client_port"))
}
// Commands that establish a SQL connection.
sqlCmds := []*cobra.Command{sqlShellCmd, userCmd, zoneCmd}
for _, cmd := range sqlCmds {
f := cmd.PersistentFlags()
f.StringVar(&connURL, "url", "", usage("url"))
f.StringVarP(&connUser, "user", "u", security.RootUser, usage("user"))
f.StringVarP(&connPort, "port", "p", base.DefaultPort, usage("client_port"))
f.StringVarP(&connDBName, "database", "d", "", usage("database"))
}
// Max results flag for scan, reverse scan, and range list.
for _, cmd := range []*cobra.Command{scanCmd, reverseScanCmd, lsRangesCmd} {
f := cmd.Flags()
f.Int64Var(&maxResults, "max-results", 1000, usage("max-results"))
}
}