open-consul/command/kv_get.go

package command

import (
	"bytes"
	"encoding/base64"
	"fmt"
	"io"
	"strings"
	"text/tabwriter"

	"github.com/hashicorp/consul/api"
	"github.com/hashicorp/consul/command/base"
)

// KVGetCommand is a Command implementation that is used to fetch the value of
// a key from the key-value store.
type KVGetCommand struct {
	base.Command
}

func (c *KVGetCommand) Help() string {
	helpText := `
Usage: consul kv get [options] [KEY_OR_PREFIX]

  Retrieves the value from Consul's key-value store at the given key name. If no
  key exists with that name, an error is returned. If a key exists with that
  name but has no data, nothing is returned. If the name or prefix is omitted,
  it defaults to "" which is the root of the key-value store.

  To retrieve the value for the key named "foo" in the key-value store:

      $ consul kv get foo

  This will return the original, raw value stored in Consul. To view detailed
  information about the key, specify the "-detailed" flag. This will output all
  known metadata about the key including ModifyIndex and any user-supplied
  flags:

      $ consul kv get -detailed foo

  To treat the path as a prefix and list all keys which start with the given
  prefix, specify the "-recurse" flag:

      $ consul kv get -recurse foo

  This will return all key-value pairs. To just list the keys which start with
  the specified prefix, use the "-keys" option instead:

      $ consul kv get -keys foo

  For a full list of options and examples, please see the Consul documentation.

` + c.Command.Help()

	return strings.TrimSpace(helpText)
}

func (c *KVGetCommand) Run(args []string) int {
	f := c.Command.NewFlagSet(c)
	base64encode := f.Bool("base64", false,
		"Base64 encode the value. The default value is false.")
	detailed := f.Bool("detailed", false,
		"Provide additional metadata about the key in addition to the value such "+
			"as the ModifyIndex and any flags that may have been set on the key. "+
			"The default value is false.")
	keys := f.Bool("keys", false,
		"List keys which start with the given prefix, but not their values. "+
			"This is especially useful if you only need the key names themselves. "+
			"This option is commonly combined with the -separator option. The default "+
			"value is false.")
	recurse := f.Bool("recurse", false,
		"Recursively look at all keys prefixed with the given path. The default "+
			"value is false.")
	separator := f.String("separator", "/",
		"String to use as a separator between keys. The default value is \"/\", "+
			"but this option is only taken into account when paired with the -keys flag.")

	if err := c.Command.Parse(args); err != nil {
		return 1
	}

	key := ""

	// Check for arg validation
	args = f.Args()
	switch len(args) {
	case 0:
		key = ""
	case 1:
		key = args[0]
	default:
		c.Ui.Error(fmt.Sprintf("Too many arguments (expected 1, got %d)", len(args)))
		return 1
	}

	// This is just a "nice" thing to do. Since pairs cannot start with a /, but
	// users will likely put "/" or "/foo", lets go ahead and strip that for them
	// here.
	if len(key) > 0 && key[0] == '/' {
		key = key[1:]
	}

	// If the key is empty and we are not doing a recursive or key-based lookup,
	// this is an error.
	if key == "" && !(*recurse || *keys) {
		c.Ui.Error("Error! Missing KEY argument")
		return 1
	}

	// Create and test the HTTP client
	client, err := c.Command.HTTPClient()
	if err != nil {
		c.Ui.Error(fmt.Sprintf("Error connecting to Consul agent: %s", err))
		return 1
	}

	switch {
	case *keys:
		keys, _, err := client.KV().Keys(key, *separator, &api.QueryOptions{
			AllowStale: c.Command.HTTPStale(),
		})
		if err != nil {
			c.Ui.Error(fmt.Sprintf("Error querying Consul agent: %s", err))
			return 1
		}

		for _, k := range keys {
			c.Ui.Info(string(k))
		}

		return 0
	case *recurse:
		pairs, _, err := client.KV().List(key, &api.QueryOptions{
			AllowStale: c.Command.HTTPStale(),
		})
		if err != nil {
			c.Ui.Error(fmt.Sprintf("Error querying Consul agent: %s", err))
			return 1
		}

		for i, pair := range pairs {
			if *detailed {
				var b bytes.Buffer
				if err := prettyKVPair(&b, pair, *base64encode); err != nil {
					c.Ui.Error(fmt.Sprintf("Error rendering KV pair: %s", err))
					return 1
				}

				c.Ui.Info(b.String())

				if i < len(pairs)-1 {
					c.Ui.Info("")
				}
			} else {
				if *base64encode {
					c.Ui.Info(fmt.Sprintf("%s:%s", pair.Key, base64.StdEncoding.EncodeToString(pair.Value)))
				} else {
					c.Ui.Info(fmt.Sprintf("%s:%s", pair.Key, pair.Value))
				}
			}
		}

		return 0
	default:
		pair, _, err := client.KV().Get(key, &api.QueryOptions{
			AllowStale: c.Command.HTTPStale(),
		})
		if err != nil {
			c.Ui.Error(fmt.Sprintf("Error querying Consul agent: %s", err))
			return 1
		}

		if pair == nil {
			c.Ui.Error(fmt.Sprintf("Error! No key exists at: %s", key))
			return 1
		}

		if *detailed {
			var b bytes.Buffer
			if err := prettyKVPair(&b, pair, *base64encode); err != nil {
				c.Ui.Error(fmt.Sprintf("Error rendering KV pair: %s", err))
				return 1
			}

			c.Ui.Info(b.String())
			return 0
		} else {
			c.Ui.Info(string(pair.Value))
			return 0
		}
	}
}

func (c *KVGetCommand) Synopsis() string {
	return "Retrieves or lists data from the KV store"
}

func prettyKVPair(w io.Writer, pair *api.KVPair, base64EncodeValue bool) error {
	tw := tabwriter.NewWriter(w, 0, 2, 6, ' ', 0)
	fmt.Fprintf(tw, "CreateIndex\t%d\n", pair.CreateIndex)
	fmt.Fprintf(tw, "Flags\t%d\n", pair.Flags)
	fmt.Fprintf(tw, "Key\t%s\n", pair.Key)
	fmt.Fprintf(tw, "LockIndex\t%d\n", pair.LockIndex)
	fmt.Fprintf(tw, "ModifyIndex\t%d\n", pair.ModifyIndex)
	if pair.Session == "" {
		fmt.Fprint(tw, "Session\t-\n")
	} else {
		fmt.Fprintf(tw, "Session\t%s\n", pair.Session)
	}
	if base64EncodeValue {
		fmt.Fprintf(tw, "Value\t%s", base64.StdEncoding.EncodeToString(pair.Value))
	} else {
		fmt.Fprintf(tw, "Value\t%s", pair.Value)
	}
	return tw.Flush()
}