| // Copyright (c) HashiCorp, Inc. |
| // SPDX-License-Identifier: MPL-2.0 |
| |
| package command |
| |
| import ( |
| "fmt" |
| "strings" |
| |
| "github.com/mitchellh/cli" |
| "github.com/posener/complete" |
| ) |
| |
| var ( |
| _ cli.Command = (*AuthHelpCommand)(nil) |
| _ cli.CommandAutocomplete = (*AuthHelpCommand)(nil) |
| ) |
| |
| type AuthHelpCommand struct { |
| *BaseCommand |
| |
| Handlers map[string]LoginHandler |
| } |
| |
| func (c *AuthHelpCommand) Synopsis() string { |
| return "Prints usage for an auth method" |
| } |
| |
| func (c *AuthHelpCommand) Help() string { |
| helpText := ` |
| Usage: vault auth help [options] TYPE | PATH |
| |
| Prints usage and help for an auth method. |
| |
| - If given a TYPE, this command prints the default help for the |
| auth method of that type. |
| |
| - If given a PATH, this command prints the help output for the |
| auth method enabled at that path. This path must already |
| exist. |
| |
| Get usage instructions for the userpass auth method: |
| |
| $ vault auth help userpass |
| |
| Print usage for the auth method enabled at my-method/: |
| |
| $ vault auth help my-method/ |
| |
| Each auth method produces its own help output. |
| |
| ` + c.Flags().Help() |
| |
| return strings.TrimSpace(helpText) |
| } |
| |
| func (c *AuthHelpCommand) Flags() *FlagSets { |
| return c.flagSet(FlagSetHTTP) |
| } |
| |
| func (c *AuthHelpCommand) AutocompleteArgs() complete.Predictor { |
| handlers := make([]string, 0, len(c.Handlers)) |
| for k := range c.Handlers { |
| handlers = append(handlers, k) |
| } |
| return complete.PredictSet(handlers...) |
| } |
| |
| func (c *AuthHelpCommand) AutocompleteFlags() complete.Flags { |
| return c.Flags().Completions() |
| } |
| |
| func (c *AuthHelpCommand) Run(args []string) int { |
| f := c.Flags() |
| |
| if err := f.Parse(args); err != nil { |
| c.UI.Error(err.Error()) |
| return 1 |
| } |
| |
| args = f.Args() |
| switch { |
| case len(args) < 1: |
| c.UI.Error(fmt.Sprintf("Not enough arguments (expected 1, got %d)", len(args))) |
| return 1 |
| case len(args) > 1: |
| c.UI.Error(fmt.Sprintf("Too many arguments (expected 1, got %d)", len(args))) |
| return 1 |
| } |
| |
| client, err := c.Client() |
| if err != nil { |
| c.UI.Error(err.Error()) |
| return 2 |
| } |
| |
| // Start with the assumption that we have an auth type, not a path. |
| authType := strings.TrimSpace(args[0]) |
| |
| authHandler, ok := c.Handlers[authType] |
| if !ok { |
| // There was no auth type by that name, see if it's a mount |
| auths, err := client.Sys().ListAuth() |
| if err != nil { |
| c.UI.Error(fmt.Sprintf("Error listing auth methods: %s", err)) |
| return 2 |
| } |
| |
| authPath := ensureTrailingSlash(sanitizePath(args[0])) |
| auth, ok := auths[authPath] |
| if !ok { |
| c.UI.Warn(fmt.Sprintf( |
| "No auth method available on the server at %q", authPath)) |
| return 1 |
| } |
| |
| authHandler, ok = c.Handlers[auth.Type] |
| if !ok { |
| c.UI.Warn(wrapAtLength(fmt.Sprintf( |
| "No method-specific CLI handler available for auth method %q", |
| authType))) |
| return 2 |
| } |
| } |
| |
| c.UI.Output(authHandler.Help()) |
| return 0 |
| } |