149 lines
3.2 KiB
Go
149 lines
3.2 KiB
Go
package command
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/hashicorp/consul/api"
|
|
"github.com/hashicorp/consul/command/base"
|
|
)
|
|
|
|
// KVImportCommand is a Command implementation that is used to import
|
|
// a KV tree stored as JSON
|
|
type KVImportCommand struct {
|
|
base.Command
|
|
|
|
// testStdin is the input for testing.
|
|
testStdin io.Reader
|
|
}
|
|
|
|
func (c *KVImportCommand) Synopsis() string {
|
|
return "Imports a tree stored as JSON to the KV store"
|
|
}
|
|
|
|
func (c *KVImportCommand) Help() string {
|
|
helpText := `
|
|
Usage: consul kv import [DATA]
|
|
|
|
Imports key-value pairs to the key-value store from the JSON representation
|
|
generated by the "consul kv export" command.
|
|
|
|
The data can be read from a file by prefixing the filename with the "@"
|
|
symbol. For example:
|
|
|
|
$ consul kv import @filename.json
|
|
|
|
Or it can be read from stdin using the "-" symbol:
|
|
|
|
$ cat filename.json | consul kv import config/program/license -
|
|
|
|
Alternatively the data may be provided as the final parameter to the command,
|
|
though care must be taken with regards to shell escaping.
|
|
|
|
For a full list of options and examples, please see the Consul documentation.
|
|
|
|
` + c.Command.Help()
|
|
|
|
return strings.TrimSpace(helpText)
|
|
}
|
|
|
|
func (c *KVImportCommand) Run(args []string) int {
|
|
f := c.Command.NewFlagSet(c)
|
|
|
|
if err := c.Command.Parse(args); err != nil {
|
|
return 1
|
|
}
|
|
|
|
// Check for arg validation
|
|
args = f.Args()
|
|
data, err := c.dataFromArgs(args)
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error! %s", err))
|
|
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
|
|
}
|
|
|
|
var entries []*kvExportEntry
|
|
if err := json.Unmarshal([]byte(data), &entries); err != nil {
|
|
c.UI.Error(fmt.Sprintf("Cannot unmarshal data: %s", err))
|
|
return 1
|
|
}
|
|
|
|
for _, entry := range entries {
|
|
value, err := base64.StdEncoding.DecodeString(entry.Value)
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error base 64 decoding value for key %s: %s", entry.Key, err))
|
|
return 1
|
|
}
|
|
|
|
pair := &api.KVPair{
|
|
Key: entry.Key,
|
|
Flags: entry.Flags,
|
|
Value: value,
|
|
}
|
|
|
|
if _, err := client.KV().Put(pair, nil); err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error! Failed writing data for key %s: %s", pair.Key, err))
|
|
return 1
|
|
}
|
|
|
|
c.UI.Info(fmt.Sprintf("Imported: %s", pair.Key))
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
func (c *KVImportCommand) dataFromArgs(args []string) (string, error) {
|
|
var stdin io.Reader = os.Stdin
|
|
if c.testStdin != nil {
|
|
stdin = c.testStdin
|
|
}
|
|
|
|
switch len(args) {
|
|
case 0:
|
|
return "", errors.New("Missing DATA argument")
|
|
case 1:
|
|
default:
|
|
return "", fmt.Errorf("Too many arguments (expected 1 or 2, got %d)", len(args))
|
|
}
|
|
|
|
data := args[0]
|
|
|
|
if len(data) == 0 {
|
|
return "", errors.New("Empty DATA argument")
|
|
}
|
|
|
|
switch data[0] {
|
|
case '@':
|
|
data, err := ioutil.ReadFile(data[1:])
|
|
if err != nil {
|
|
return "", fmt.Errorf("Failed to read file: %s", err)
|
|
}
|
|
return string(data), nil
|
|
case '-':
|
|
if len(data) > 1 {
|
|
return data, nil
|
|
}
|
|
var b bytes.Buffer
|
|
if _, err := io.Copy(&b, stdin); err != nil {
|
|
return "", fmt.Errorf("Failed to read stdin: %s", err)
|
|
}
|
|
return b.String(), nil
|
|
default:
|
|
return data, nil
|
|
}
|
|
}
|