Hide advanced commands from cipd client help.

client/authcli/authcli.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // Package authcli implements authentication related CLI subcommands.
 //
 // It can be used from CLI tools that want customize authentication
 // configuration from the command line.
 //
 // It use luci-go/common/cli.GetContext() to grab a context for logging, so
@@ skipping 42 matching lines @@
         "github.com/maruel/subcommands"
         "golang.org/x/net/context"
         "golang.org/x/net/context/ctxhttp"
 
         "github.com/luci/luci-go/common/auth"
         "github.com/luci/luci-go/common/cli"
 )
 
 // CommandParams specifies various parameters for a subcommand.
 type CommandParams struct {
-        Name string // name of the subcommand.
+        Name     string // name of the subcommand.
+        Advanced bool   // subcommands should treat this as an 'advanced' command
 
         AuthOptions auth.Options // default auth options.
 
         // ScopesFlag specifies if -scope flag must be registered.
         // AuthOptions.Scopes is used as a default value.
         // If it is empty, defaults to "https://www.googleapis.com/auth/userinfo.email".
         ScopesFlag bool
 }
 
 // Flags defines command line flags related to authentication.
@@ skipping 39 matching lines @@
         params *CommandParams
 }
 
 func (c *commandRunBase) registerBaseFlags() {
         c.flags.registerScopesFlag = c.params.ScopesFlag
         c.flags.Register(&c.Flags, c.params.AuthOptions)
 }
 
 // SubcommandLogin returns subcommands.Command that can be used to perform
 // interactive login.
-func SubcommandLogin(opts auth.Options, name string) *subcommands.Command {
-        return SubcommandLoginWithParams(CommandParams{Name: name, AuthOptions: opts})
+func SubcommandLogin(opts auth.Options, name string, advanced bool) *subcommands.Command {
+        return SubcommandLoginWithParams(CommandParams{Name: name, Advanced: advanced, AuthOptions: opts})
 }
 
 // SubcommandLoginWithParams returns subcommands.Command that can be used to perform
 // interactive login.
 func SubcommandLoginWithParams(params CommandParams) *subcommands.Command {
         return &subcommands.Command{
+                Advanced:  params.Advanced,
                 UsageLine: params.Name,
                 ShortDesc: "performs interactive login flow",
                 LongDesc:  "Performs interactive login flow and caches obtained credentials",
                 CommandRun: func() subcommands.CommandRun {
                         c := &loginRun{}
                         c.params = &params
                         c.registerBaseFlags()
                         return c
                 },
         }
@@ skipping 19 matching lines @@
         if canReportIdentity(opts.Scopes) {
                 if err = reportIdentity(ctx, authenticator); err != nil {
                         return 3
                 }
         }
         return 0
 }
 
 // SubcommandLogout returns subcommands.Command that can be used to purge cached
 // credentials.
-func SubcommandLogout(opts auth.Options, name string) *subcommands.Command {
-        return SubcommandLogoutWithParams(CommandParams{Name: name, AuthOptions: opts})
+func SubcommandLogout(opts auth.Options, name string, advanced bool) *subcommands.Command {
+        return SubcommandLogoutWithParams(CommandParams{Name: name, Advanced: advanced, AuthOptions: opts})
 }
 
 // SubcommandLogoutWithParams returns subcommands.Command that can be used to purge cached
 // credentials.
 func SubcommandLogoutWithParams(params CommandParams) *subcommands.Command {
         return &subcommands.Command{
+                Advanced:  params.Advanced,
                 UsageLine: params.Name,
                 ShortDesc: "removes cached credentials",
                 LongDesc:  "Removes cached credentials from the disk",
                 CommandRun: func() subcommands.CommandRun {
                         c := &logoutRun{}
                         c.params = &params
                         c.registerBaseFlags()
                         return c
                 },
         }
@@ skipping 13 matching lines @@
         err = auth.NewAuthenticator(ctx, auth.SilentLogin, opts).PurgeCredentialsCache()
         if err != nil {
                 fmt.Fprintln(os.Stderr, err)
                 return 2
         }
         return 0
 }
 
 // SubcommandInfo returns subcommand.Command that can be used to print current
 // cached credentials.
-func SubcommandInfo(opts auth.Options, name string) *subcommands.Command {
-        return SubcommandInfoWithParams(CommandParams{Name: name, AuthOptions: opts})
+func SubcommandInfo(opts auth.Options, name string, advanced bool) *subcommands.Command {
+        return SubcommandInfoWithParams(CommandParams{Name: name, Advanced: advanced, AuthOptions: opts})
 }
 
 // SubcommandInfoWithParams returns subcommand.Command that can be used to print current
 // cached credentials.
 func SubcommandInfoWithParams(params CommandParams) *subcommands.Command {
         return &subcommands.Command{
+                Advanced:  params.Advanced,
                 UsageLine: params.Name,
                 ShortDesc: "prints an email address associated with currently cached token",
                 LongDesc:  "Prints an email address associated with currently cached token",
                 CommandRun: func() subcommands.CommandRun {
                         c := &infoRun{}
                         c.params = &params
                         c.registerBaseFlags()
                         return c
                 },
         }
@@ skipping 34 matching lines @@
 // SubcommandToken returns subcommand.Command that can be used to print current
 // access token.
 func SubcommandToken(opts auth.Options, name string) *subcommands.Command {
         return SubcommandTokenWithParams(CommandParams{Name: name, AuthOptions: opts})
 }
 
 // SubcommandTokenWithParams returns subcommand.Command that can be used to print current
 // access token.
 func SubcommandTokenWithParams(params CommandParams) *subcommands.Command {
         return &subcommands.Command{
+                Advanced:  params.Advanced,
                 UsageLine: params.Name,
                 ShortDesc: "prints an access token",
                 LongDesc:  "Generates an access token if requested and prints it.",
                 CommandRun: func() subcommands.CommandRun {
                         c := &tokenRun{}
                         c.params = &params
                         c.registerBaseFlags()
                         c.Flags.DurationVar(
                                 &c.lifetime, "lifetime", time.Minute,
                                 "Minimum token lifetime. If existing token expired and refresh token or service account is not present, returns nothing.",
@@ skipping 137 matching lines @@
         fmt.Printf("Logged in as %s.\n", reply.Email)
         fmt.Printf("OAuth token details:\n")
         fmt.Printf("  Client ID: %s\n", reply.IssuedTo)
         fmt.Printf("  Scopes:\n")
         for _, scope := range strings.Split(reply.Scope, " ") {
                 fmt.Printf("    %s\n", scope)
         }
 
         return nil
 }